15 ms·
Languages I want to write
- cwp 8y agoOoh. Dependent types and borrow checking. Yes please. I'm into tools, so the weird language/environments I'd like to write include: * A language where the program is constructed by editing a running process in-place with a debugger/IDE, then the process is "saved" as an executable. * An iPad app that lets people draw dataflow programs with a pencil * A SQL dialect that compiles to Kinesis streams and EC2 instances
- mhluongo 8y ago> A language where the program is constructed by editing a running process in-place with a debugger/IDE, then the process is "saved" as an executable. It's been a few years, but this reminds me of learning Smalltalk back in the day, as well as how some Lisps (CL?) treat the VM as the program being produced
- protomyth 8y agoI knew a couple of Smalltalkers that would write their programs in the debugger. Its pretty good for rapidly figuring out what you need to get the job done, and then they would go back with the refactoring browser to clean it up and get it in line with the rest of the system.
- 4thaccount 8y agoSmalltalk is like this and so is SBCL with Emacs Slime mode.
- andrewflnr 8y ago> A language where the program is constructed by editing a running process in-place with a debugger/IDE, then the process is "saved" as an executable. Why do people want this? I honestly don't understand. The point of code as opposed to just doing stuff by hand is that you can edit the code independently of its execution. You can fully inspect it without running it, and without any weird crevices for information to hide in. The workflow where you sort of edit and save processes, like smalltalk images, seems like it would throw away those advantages.
- rabidrat 8y agoIt allows rapid productization by combining experimentation and development into a single process. The dream is to do something just once manually, and then have it automated with no further effort. This is why Excel is one of the most used programming environments.
- mpweiher 8y ago> editing a running process in-place with a debugger/IDE, then the process is "saved" as an executable I am currently working on a variant of the Smalltalk image concept that works this way, based on Objective-Smalltalk[1] You have documents in a live coding environment, and those documents can be saved as executables. One inspiration is DropScript[2], which was an app that converted Unix scripts into (simple) MacOS X apps. Another is obviously Smalltalk. > An iPad app that lets people draw dataflow programs with a pencil Objective-Smalltalk also has pretty good dataflow support. Drawing would be a reasonable addition. [1] http://objective.st http://objective.st [2] http://www.wsanchez.net/papers/DropScript/ http://www.wsanchez.net/papers/DropScript/
- cwp 8y agoHi Marcel! I'm thinking of something that would be a lot like Smalltalk, but with strict separation between program and metaprogram. (In the spirit of Alan Kay's notion of fences between metaboundaries). The IDE would run in a separate process from the program, and attach to the program via operating system debugging facilities. I think most of the problems with Smalltalk can be traced back to its origin as an operating system and the mingling of the program and tools for writing the program in the same image. Eg, shrink scripts for deployment.
- mpweiher 8y ago> via operating system debugging facilities. That's an interesting approach, let me know how it works out! In my previous efforts, I just used a small HTTP server inside the target program. You can see it in action here, fine-tuning an iOS target: https://www.youtube.com/watch?v=ArcClqt2vTc https://www.youtube.com/watch?v=ArcClqt2vTc Since it's HTTP, it also works on the device. You can obviously also access those facilities from within the process, at least for a macOS app. Right now, I am focusing on a more image-like user-experience, but with individual (small-ish) documents instead of a huge monolithic image. The difference in trying out UI-oriented idea compared to having to create a separate Xcode project each time is huge, and of course jut doing it live without restarting. My guess is that these documents will evolve to be a lot like .frameworks, so code + resources. Budding an app is then no more than just copying the app shell and filling it with the right frameworks. (See Xcode). Once budded, you might interact via the HTTP route. Or maybe via debugger?
- ewhauser421 8y agoGoogle announced Dataflow SQL recently. Not too many details on it yet but should be close to what you want
- TeMPOraL 8y ago> A language where the program is constructed by editing a running process in-place with a debugger/IDE, then the process is "saved" as an executable. Others mentioned Smalltalk, but this is exactly how Common Lisp, and many (most) other Lisps work. In Common Lisp, you start with a process that has a compiler (or interpreter, depending on implementation) and a REPL, and everything you do from there is modifying that process, called "an image". After you're done, you can dump the image into a standalone executable (but unless you're distributing executables or care about startup time, it's not something you'll likely do). Source code in Lisp is really a set of operations you do on that image.
- cwp 8y agoSorry, I should have given more detail. Both Smalltalk and Lisp use reflection for editing in place. The IDE, or REPL, is part of the process being edited. I'd like to use an external debugger, based on ptrace or the like, to accomplish the same development style, but without (necessarily) having any reflection in the program being developed, and without the need for tooling code comingled with program code.
- chriswarbo 8y ago> A language where the program is constructed by editing a running process in-place with a debugger/IDE, then the process is "saved" as an executable. Another fun language which does this is Factor https://factorcode.org https://factorcode.org
- javajosh 8y agoI don't have first-hand knowledge of it, but I understand that Smalltalk was/is developed like this - and it has significant drawbacks.
- azhenley 8y agoA programming language that is designed to be spoken. It could be great for those with disabilities.
- setr 8y agoUrbit defines pronunciations for all of its sigils with the goal of enabling verbal communication of its forms; however, it makes no attempt to be sensible language, its more of just random english syllables that compose without too much harshness, justified by the use of greek letters in mathematics (part of their value is they have little/no context to bring in, so you can freely build your own)
- thanksDr 8y agoI look forward to seeing what we learn from urbit ten years from now. 0=true? Crazy sigils, three ways? I just went back to their website to remember the special name they used for distributed computation, and they have introduced /even more new words and layers!/ Godspeed, you.
- michaelmrose 8y agoWhy not python? On a broader topic seems like speaking punctuation would work fine if the environment were smart about where to put it in context. Seems like there would be a ton of value in an environment that used what makes sense in terms of the programming language in terms of recognition. If a word is slightly more likely to be foo than bar but bar is an identifier maybe its more likely to be bar? Again this really seems like a case for a smart environment or even just a smart addon for an existing environment rather than a new language.
- andrewl-hn 8y agoI talked to a three different blind programmers in the last few years. They all dismissed Python and other indentation-based languages, because - surprise-surprise - screen readers don't read out significant whitespace.
- bjz_ 8y ago> A language with dependent types and borrow checking I'm definitely interested in this! There are significant challenges here though, particularly with respect to combining dependent types with effects and coeffects! This is open research, but significant progress is being made, and I'm hopeful. I'm currently keeping an eye on https://github.com/granule-project/granule https://github.com/granule-project/granule, which seems like it might have some interesting things to say about this. Currently I'm trying to learn how to implement dependent types in my programming language, Pikelet: https://github.com/pikelet-lang/pikelet https://github.com/pikelet-lang/pikelet (currently doing a rebuild of the front-end in https://github.com/brendanzab/rust-nbe-for-mltt https://github.com/brendanzab/rust-nbe-for-mltt). I'm hoping that once I've done this I might eventually be able to start looking at implementing something to do with borrow checking in it, but who knows! The more I learn the less I seem to know! Always interested in chatting to people about this at our Gitter channel: https://gitter.im/pikelet-lang/Lobby https://gitter.im/pikelet-lang/Lobby > Idris is perhaps the most famous dependently typed language. I'd probably put Coq and Agda ahead of Idris in terms of being well known and established, but Idris is certainly pretty cool in how it tries to target practical programming.
- iamrecursion 8y agoA good foundation for such a language would be one based on Quantitative Type Theory [0]. It’s a dependent type theory that records usage information in every typing judgement. The Idris successor, Blodwen [1] is being based on it. [0] https://bentnib.org/quantitative-type-theory.pdf https://bentnib.org/quantitative-type-theory.pdf [1] https://github.com/edwinb/Blodwen https://github.com/edwinb/Blodwen
- bjz_ 8y agoYeah, I'm aware of Quantitative Type Theory, it's very cool! Another neat iteration is described in "Resourceful Dependent Types"[0]. I'm interested in what the Granule people are doing though - they can track usage information at the type level too. It's still non-dependent for now, but I hear that they are interested in extending it to dependent types too. They use an SMT solver to track usage information which is really neat - apparently it allows to track more interesting usage patterns than Blodwen can. Sadly this doesn't do everything I want though - AFAIK, you can still have multiple out-standing references in linear typing [1]. I'd really like some story for uniqueness too in order to have support for in-place updates while avoiding a GC. [0]: http://www2.tcs.ifi.lmu.de/~abel/talkTYPES18.pdf http://www2.tcs.ifi.lmu.de/~abel/talkTYPES18.pdf [1]: https://en.wikipedia.org/wiki/Uniqueness_type#Relationship_to_linear_typing https://en.wikipedia.org/wiki/Uniqueness_type#Relationship_t...
- c3534l 8y agoI've always liked the idea of a language that combined syntax level support for functional reactive programming and symbolic programming. So you define z as x + y. Then you change the value of x and that change cascades across your program, like a spreadsheet almost.
- jmickey 8y agoI understand that is how object oriented databases work. For example, you can define the equation for a financial derivative, then change the price of one of the components and derivative price is updated automatically.
- lifthrasiir 8y agoTry Mozart/Oz [1]. For example, a symbolic constraint solver for Minesweeper [2] had been written in it. [1] https://mozart.github.io/ https://mozart.github.io/ [2] https://www.info.ucl.ac.be/~pvr/minesweeper.pdf https://www.info.ucl.ac.be/~pvr/minesweeper.pdf
- voldacar 8y agoYou can do this easily in lispy languages with eval
- etatoby 8y agoIsn't that Haskell? Or any other declarative, lazily-evaluated landuage. Granted, you need to use something like the ST monad to be able to "change the value of x," but once you do, all other values fall into place like dominoes.
- barrkel 8y agoThat's pull rather than push, though.
- geocar 8y agok/q does this. They're called views[1] z::x+y x:42 y:42 z y:69 z [1]: https://code.kx.com/v2/ref/view/ https://code.kx.com/v2/ref/view/
- ncmncm 8y agoAm I confused, or is Wesley? C++ supports dependent types: template<typename T> T add(T, T); C++ doesn't have borrow checking. Maybe he means no non-obligate-GC language has dependent types and borrow checking?
- net4all 8y agoIn the example the return type of add does not depend on the value of the arguments. So it is not dependent types.
- Davidbrcz 8y agoIn this piece of code, the return type is explicitly dependent of the type of the argument (it's path related template #include <iostream> #include <string> struct A {using ret = std::string;}; struct B {using ret = int;}; template <class T> auto f(T t) -> typename T::ret { return {}; } int main(int argc, char *argv[]) { auto s = f(A{}); std::cout << s.size() << "\n"; auto i = f(B{}); std::cout << i+1 << "\n"; return 0; } There is also stuff like this where the return type is defined as the return type of builder.makeObject(), builder which is the argument: template <typename Builder> auto makeAndProcessObject (const Builder& builder) -> decltype(builder.makeObject() ) { auto val = builder.makeObject(); // do stuff with val return val; }
- Retra 8y agoThe return type has to be dependent on the value of the input, not its type. Like it'll return an int[3] if you provide 3 as in input and int[4] if you provide 4. Note that both 3 and 4 should have the same type, but int[3] and int[4] are different types.
- TheAsprngHacker 8y agoAs net4all pointed out, your C++ example isn't really dependent types. It's achievable with parametric polymorphism a la System F, AKA the ML-style or Java-style generics. C++ does have value arguments for templates, however. Perhaps a better example would have been std::array, which takes a size as an argument. However, C++ still doesn't really have dependent types the same way Agda or Idris has them. One big difference is that C++ templates are only checked upon instantiation. So, this code: template<typename T, T a> std::array<int, a + 1> add() { return {1, 2}; } compiles, but when I try to do add<int, 0>() the compiler complains. Because the dependent function type means "forall," it's important that the compiler make sure that it truly does work for all inputs.
- jodrellblank 8y agoOne with no errors. There's no concept of a "syntax error" or a "compiler error" or a function error. One of the most common things we joke about is people not reading error messages. Whatever the design is, it would not ever spit a big red blob in your face which makes you wince and feel bad, nor would it fill your terminal - the place where you work - with screen after screen of tracebacks. It is unthinkable that you could write "x-1 = x+1" on a piece of paper and the equation scribbles on your workplace and you can't use it anymore. There would be no adversarial relationship, you wouldn't be "fighting" the compiler or the borrow checker, no red squiggly underlines in an IDE. The whole approach would be reframed into the computer being a mechanical assistant helping you solve problems and guiding you towards success instead of slapping you. A tuning fork plays a tone you can use to tune a piano string. It doesn't slap you if tweak the string tuning the wrong way. An archery target lets you see when you miss the centre, it doesn't also shout at you. Code not working is feedback all by itself. The tools shouldn't add negative feedback to that, they should guide towards where working is.
- sk0g 8y agoWould testing be off limits in this language as well? It is, after all, the computer screaming at you that your code doesn't work as you expect it to. If so, not a language I'd consider using. Or one that I could see getting any sort of use in a production environment, but that might just be me.
- michaelmrose 8y agoif you write x-1 = x + 1 on a piece of paper it just sits there silently being wrong but code runs it shows information on the screen, it launches misles or intercepts them, it helps your phone play a tune or make a phone call. All of this is complex work not merely because we are making it harder but because we are asking more and more. Short of AI its infinitely more useful to have an exact answer to what went wrong instead of just silently not doing the correct thing because this is ultimately much harder to reason about. I'm not sure how your kinder gentler world is even supposed to function or how you imagine you are supposed to work without better not worse tools giving you negative feedback when inevitably things go wrong.
- yxhuvud 8y agoHe wants a python with algebraic data types? I wonder if he has looked at Crystal. Itis neither, but still perhaps close enough. Ruby espressabilty and a type system that while probably not powerful enough to be classified as algebraic, still is powerful enough to have things like sum types.
- brabel 8y ago> A python-esque language with algebraic data types I think [Pony](https://tutorial.ponylang.io/types/type-expressions.html https://tutorial.ponylang.io/types/type-expressions.html) is close to being that (but it has much more, like Actors and reference capabilities).
- 3jckd 8y agoI don't know much about Pony but glancing over the doc it seems very Scala-ish, which can already be written in very pythonic way and has ADTs. Am I missing something here?
- coldtea 8y agoThat Scala is a beast of a language with a huge surface syntax?
- pkolaczk 8y agoIt is not. Its syntax is simpler and more regular than Java or C#, and on par with Kotlin. I haven't heard many complaints on them having complex syntax. Ironically Kotlin is promoted as simple, when its syntax is almost the same as Scala.
- divs1210 8y agoSurely, you must be joking? Scala is much closer to C++ than Java, forget Kotlin. It is a kitchen sink with every feature under the sun.
- pkolaczk 8y agoThen how come most Scala code can be translated to/from Kotlin or Swift with just find-and-replace? https://hackernoon.com/how-i-ported-10k-lines-of-scala-to-kotlin-in-one-week-c645732d3c1 https://hackernoon.com/how-i-ported-10k-lines-of-scala-to-ko... The syntax of both is extremely similar. https://leverich.github.io/swiftislikescala/ https://leverich.github.io/swiftislikescala/ Basically Swift and Kotlin based their syntax exactly on Scala. > It is a kitchen sink with every feature under the sun. You obviously don't know Scala and you're just repeating BS found on the Internet. Scala is a much more powerful and much more abstract language than Kotlin, so comparing their syntax complexity is unfair from the start. But if you restrict the problem space to what can be covered by both Scala and Kotlin, then Scala has in fact fewer features than Kotlin. It just happens to have a few more generic, and very powerful unique features, which might look unfamiliar to Java programmers. Examples: * Kotlin has special syntax for null-checking. Scala has no special syntax and implements the same feature in the standard library. * Kotlin has special syntax for coroutines. Scala achieves the same with a library. * Kotlin has special syntax for extension methods. Scala doesn't provide special syntax for extension methods - they can be created with implicit objects which are a much more generic feature and have other important use cases not possible in Kotlin nor Java. * Java has special syntax for array access. Scala does not. * Java has special syntax for interfaces with method implementations. Scala does not. * Java has static members which are completely alien to OOP. Scala does not. * Kotlin and Java have operators, and Kotlin has operator overloading (just like C++!), making operators second class citizen. Scala has just method names, so "operators" and regular methods are the same. > Scala is much closer to C++ than Java Only in terms of abstraction power (IMHO it is much above C++ in abstraction power; actually much closer to OCaml than C++), but not in terms of complexity. Scala language specification is ~200 pages long. Java is ~750 pages, C++ is ~1300 pages.
- IshKebab 8y agoA sane shell language would be nice. Powershell is closer than most, but it still has some pretty WTF aspects, like `-lt` instead of `<` and how lists collapse.
- v3gas 8y agoCheck out Oil! https://www.oilshell.org https://www.oilshell.org
- tobr 8y agoI would like to make a lightweight markup language for text and data, with some concept of possible future revisions. So when you try to commit a new revision of a file, it could automatically be verified as a valid edit of a specific previous revision.
- pdamoc 8y agoWhat I would love to see is a declarative object oriented language. It would marry the idea of FauxO from Gary Bernhardt's Boundaries talk [1] with the syntax of Elm. Elm already allows for escaping into other languages. I would love to see that mechanism expanded and a bunch of "core" DSLs implemented using ideas from the "STEPS Toward the Reinvention of Programming" [2]. [1] https://www.destroyallsoftware.com/talks/boundaries https://www.destroyallsoftware.com/talks/boundaries [2] http://www.vpri.org/pdf/tr2012001_steps.pdf http://www.vpri.org/pdf/tr2012001_steps.pdf
- vanderZwan 8y ago> An effect system for Forth I have to confess that I don't know what exactly entails an "effect system", but Kitten trying to achieve something like that? http://kittenlang.org/ http://kittenlang.org/
- chriswarbo 8y agoAn effect system is like a type system, but keeps track of the 'effects' (think 'side effects', but we're doing them on purpose) that may occur when evaluating an expression. For example `print` might have a `log` effect. Unlike types, which get 'consumed' (e.g. by calling a function with an argument), effects tend to accumulate. I've mostly seen effect systems in the form of 'algebraic effect handling', which allow effects to be "handled" in a similar way to try/catch for (resumable) exceptions. For example, if we have an expression with the `log` effect, our tests might wrap it in a handler which just accumulates a string, so we can test what was logged; our production system might use a handler that plugs into an external logging system (which would require an effect like 'IO' or 'socket' or something). Stack languages like Forth and Kitten have "stack effects", which are the effects that evaluating an expression has on the stack, e.g. popping some values. Effects are sort of the inverse of capabilities: an expression with effect E tells us "evaluating this expression might result in E happening", whilst an expression with capability C says "to evaluate this expression, you must allow me to C".
- zeckalpha 8y agoAlso, Factor has an effect system like the one described: https://factorcode.org https://factorcode.org
- tech2 8y agoSomething with jq's filtering (and likewise JMESPath) and output for stream processing could be quite interesting indeed. In terms of my own pet desires for a language I was always a little sad that the iteration constructs from ICSI's Sather didn't see more love.
- zebproj 8y ago> I spent this weekend writing a Forth designed for music synthesis I'd be very curious to learn more about this project. I've been building these myself [0] for a few years now. [0] https://paulbatchelor.github.io/proj/sporth.html https://paulbatchelor.github.io/proj/sporth.html
- a_imho 8y agoWhat programming languages do you want to see? A programming language focused on usability, along the lines of https://news.ycombinator.com/item?id=19478086 https://news.ycombinator.com/item?id=19478086
- zoul 8y agoElm (elm-lang.org) does some of that.
- pjc50 8y agoMy own personal list: - Verilog replacement with composite types, explicit state/functional separation and pipelining assistance - "English like" language designed with reading aloud in mind - typesafe macro assembler with memory safety assistance
- __s 8y agoFor "English like" see Inform, a language for creating interactive fiction: https://en.wikipedia.org/wiki/Inform https://en.wikipedia.org/wiki/Inform I always find "English like" languages difficult, as if there's the effort of translating my thoughts twice. Somewhat like how one might learn a language & try translating it to their native tongue, but to be fluent one has to directly translate the new language to the abstract symbols of the mind, which is _not_ words in the native tongue What I'm suggesting here is that programming languages are closer to mapping to our mind's abstract representation of programs as graphs than prose is. Prose is optimized for communicating things in the real world, not specifying programs, which tend to be elaborate filing systems That's the issue one has programming in English without bringing up the difficulty of actually writing a good parser for English & having multiple people agree on its interpretation. If I'm programming in English, let it be my English, not yours
- fanf2 8y agoHow close is bluespec to your thoughts on a verilog replacement? eg https://www.cl.cam.ac.uk/research/security/ctsrd/beri/ https://www.cl.cam.ac.uk/research/security/ctsrd/beri/
- pjc50 8y agoThat looks promising on initial inspection of e.g https://github.com/CTSRD-CHERI/beri/blob/master/cheri/trunk/DCacheClassic.bsv https://github.com/CTSRD-CHERI/beri/blob/master/cheri/trunk/... , although possibly a bit more imperative than I had in mind - still has for(). If I was working on HDL commercially I'd definitely give it a deeper look.
- nn3 8y ago-Verilog: How about https://chisel.eecs.berkeley.edu/ https://chisel.eecs.berkeley.edu/? Not sure about the pipelining assistance. - COBOL - typesafe macro assembler: WASM, low level JVM, .NET IL ... I think there were some research papers with "real" assembler too.
- krcz 8y agoLanguages I'd like to write: * a language with a mix of contracts and refinement types: encoding preconditions and postconditions in types of input and output values. this way one can match postconditions of one function and precodnitions of the next. but programmer wouln't have to prove everything: the checks could be run-time or disabled overall, enabled just for testing, which could replace unit tests - asserting all conditions for example inputs would be enough, * a language with possibility of restricting computational model per subroutine. not everything requires Turing completeness. orthogonally, most functions can be pure. the goal would be to stick to simpler models if you can and only use more complex one in small part of the codebase, * a language with possibility of user defined linear types (/ affine types / relevant types), e.g. make it possible to require having every exception logged as an error, unless explicitly ignored, * a language designed to be translated into other languages with the translation being readable code (in contrast to CLJS, ScalaJs, etc.), as idiomatic as possible; e.g. translating map / filter chains to loops when translating to imperative language. This might be as well one language, but as complexity rises exponentially, it might be better to start with few smaller ones instead.
- ellius 8y agoLove bullet #2. Being able to start with more constrained features and using more powerful techniques when necessary would be a huge aid in developing good architectures.
- krcz 8y agoIn such case I highly recommend Noether: Symmetry in Programming Language Design presentation by Daira Hopwood: https://www.infoq.com/presentations/noether https://www.infoq.com/presentations/noether. It explores the idea by describing a possible stack of sublanguages ranked from simple and easy to reason about to complex and robust.
- nn3 8y agoDon't we already have that to some degree in GNU C? gcc has an __attribute__((pure)) (not sure if it enforces it though) and there are C++ constexprs.
- marklemay 8y agoATS seems relevant, it has dependent types and linear types. My understanding isthat linear types have a lot in common with barrow checking.
- nwmcsween 8y agoRegarding language #1: * some form of resource awareness like raml.co. * a cli tool to compute resource awareness based on args provided, e.g. `ra --mem On, --time O1 file.ex file2.ex file3.ex` that all implement a single interface.
- 7373737373 8y agoI'm building https://esolangs.org/wiki/RarVM https://esolangs.org/wiki/RarVM - wanna join? :)
- PorterDuff 8y agoSince I've mostly lost interest in computer science, my goals are much more modest. I think I'd like to pound out a language that succinctly describes sheet music. I've seen at least one, but I think I could do a better job. The toolkit would probably include a realtime display showing the results of the interpreter in order to avoid a PITA save_file/convert_file/look_at_output cycle. This would be especially useful on smaller projects like leadsheets.
- 52-6F-62 8y agoThat sounds interesting. Which languages have you seen so far that are along those lines?
- mklein994 8y agoLilyPond comes to mind. http://lilypond.org/ http://lilypond.org/
- c256 8y agoHave you seen Lilypond? http://lilypond.org/ http://lilypond.org/
- PorterDuff 8y agoI've tried it before, but ended up with MuseScore for everything. What I'm thinking about is more like this: http://www.arkkra.com/ http://www.arkkra.com/ A problem I see in music scoring software is that they are waay to complicated. You end up with all the possibilities in that world even when you just need a few features in your own corner. What I'd like would be a way to really efficiently do a jazz leadsheet like you'd see in a fakebook. That cuts the notation down quite a lot. The idea is that you could type in something from an existing sheet really quickly in order to do things like edit it or change the key...or you could bang out something from transcribing. Spend some time getting it to have a good handwritten look on output. After that, add just enough stuff to do big band (or small group) charts. But no more.
- protomyth 8y agoI still think a decent Agent Oriented Language is possible. Something that takes into account proper agent communication and is not just a Smalltalk variant or a Java framework.
- rsstack 8y agoJust to understand better what you mean: how would it differ from Erlang/Elixir?
- protomyth 8y agoErlang is an actor language, see https://www.cs.huji.ac.il/~imas/readings/shoham93.pdf https://www.cs.huji.ac.il/~imas/readings/shoham93.pdf for agents
- pjmlp 8y agoYou just reminded me of Agent Tcl. https://www.cs.dartmouth.edu/~dfk/agents/papers/kotz:jmobile.pdf https://www.cs.dartmouth.edu/~dfk/agents/papers/kotz:jmobile...
- protomyth 8y agoI thought Agent Tcl was about half way there. It just felt like the infrastructure didn't quite get over that hump that would have allowed it to be a success. I do admire the effort.
- blacksqr 8y agoAGNI: a multi-threaded middleware for distributed scripting (2000) "We present the design of a AGNI a Tcl 8.1 based Middleware for building reactive, extensible, reconfigurable distributed systems" https://www.semanticscholar.org/paper/AGNI%3A-a-multi-threaded-middleware-for-distributed-Bednarek-Pors/cecf246d2fe4fb428490039f557f157ad716ef10 https://www.semanticscholar.org/paper/AGNI%3A-a-multi-thread...
- FrankHB 8y agoI'd like to continue to develop something based on vau calculi with some forms of partial evaluators, since I have lost interest in type theories.
- snrji 8y agoNoob question: don't dependent typing requires the language to be dynamic? How do you check dependencies in types otherwise (eg. the size of an array)?
- miloignis 8y agoIf I understand your question, generally the compiler would use a theorem prover / SAT solver to prove that the constraints of the dynamic types were always upheld. If it can't, in some languages this is a compiler error. In others it will introduce runtime checks (but this still doesn't require a fully dynamic language, as such, but it is in a sense partially dynamic).
- notacoward 8y agoThe language I want to write would have built-in support for the flow of control within a single function to flow seamlessly across multiple processes/machines. I don't mean fancy RPC. That still requires the programmer to break up the parts that run in different places into separate functions and callbacks, define the arguments that get passed between them, etc. I mean the compiler knows about the notion of a "place" and which data exists in each place. When it hits an "on (place)" construct it can figure out what needs to be passed, handling it for you between one line and the next. Fuller explanation here: http://obdurodon.silvrback.com/distributed-functions http://obdurodon.silvrback.com/distributed-functions This doesn't completely free the programmer from worrying about distributed-programming concerns such as node failure and broken connections. Nothing will. However, the fact that the flow of control and data looks like that of a local sequential program would make such code easier to write, test, and formally verify. I see a lot of bugs in the distributed systems I work on that occur because the low-level mechanisms are so intrusive that programmers can't (or just don't) test or verify the higher-level behaviors.
- 7373737373 8y agoHave look at the https://en.wikipedia.org/wiki/E_(programming_language) https://en.wikipedia.org/wiki/E_(programming_language) !