12 ms·
Dada, an experimental new programming language
- owenbrown 3y agoEvery time I see a new language, I immediately check if it uses significant white space like Python. If it doesn’t, I sigh sadly and dismiss it.
- csjh 3y agoWhy?
- RamtinJ95 3y agoThis is such a weird take... I just want to know why is that SO important to you? For me that is one of the things that I like the least with Python.
- diggan 3y agoCurious, I have the very opposite reaction, although I tolerate Python, but only for the massive amount of libraries and huge community. But as a language? Meh What makes you so reliant on significant white space that any language without is a automatic dismissal?
- bmitc 3y agoI thought the creators of Rust were creator, singular, in Graydon Hoare. Are they involved with this?
- steveklabnik 3y agoGraydon does not have any commits in the repository.
- estebank 3y agoNiko has been involved with Rust since before they had conceived of the borrow checker and the entire commiter list could be fed with a pizza.
- bmitc 3y agoI would distinguish creator(s) from early key contributors and developers. I'm not aware of the full history of Rust but was under the understanding that Graydon Hoare is the creator of the language.
- nickm12 3y agoIt's complicated. Graydon Hoare is the founder of the Rust project and led it through its early days, but left the project before its 1.0. The Rust that shipped shares the tenets of the Rust that Graydon created, but it is also different in some foundational ways. Graydon has written about this (and also why he left the Rust project) online. https://graydon2.dreamwidth.org/307291.html https://graydon2.dreamwidth.org/307291.html https://www.reddit.com/r/rust/comments/7qels2/i_wonder_why_graydon_hoare_the_author_of_rust/ https://www.reddit.com/r/rust/comments/7qels2/i_wonder_why_g...
- dist-epoch 3y ago> Dada is object-oriented, though not in a purist way Are classes cool again?
- speed_spread 3y agoOnly the upper ones.
- bananapub 3y agowhat does "creators of rust" mean? Graydon? niko? pcwalton?
- fbn79 3y agoniko judging from Github commits https://github.com/dada-lang/dada/graphs/contributors https://github.com/dada-lang/dada/graphs/contributors
- bananapub 3y agoah, thank you! I couldn't find anything on the website itself, should have thought to look at the code.
- lifthrasiir 3y agoIt is indicated in the last paragraph of the FAQ: https://dada-lang.org/docs/about/faq https://dada-lang.org/docs/about/faq (It is indeed hard to find though!)
- peterhull90 3y agoAlso Brian Anderson (brson) was/is a significant rust contributor
- brabel 3y agoIf the claim that its performance will be similar to Rust's if you add type annotations, this could become a really attractive language! As easy as JavaScript to write, as fast as Rust when the extra effort to write it justifies it.
- wokwokwok 3y agoThere’s no claim to be as easy as javascript to write. Rusts “difficulty” stems from its single ownership model, and this model is “different” not “easier”. https://dada-lang.org/docs/dyn_tutorial/permissions https://dada-lang.org/docs/dyn_tutorial/permissions
- rubyfan 3y agoFrom what it looks more expressive and seems intuitive to me.
- DinaCoder99 3y agoI personally find the semantics of javascript a lot harder to internalize than rust due to its scoping and very unintuitive object system. I can't imagine this is any more difficult than that.
- jokethrowaway 3y agoI agree but most modern JS doesn't use prototypal inheritance. JS has plenty of bad parts you shouldn't use. Classes are the main one.
- iopq 3y agoI had a coworker who wrote return { ... } And JS helpfully inserted a semi-colon after return This is a feature you need to know about and you have to go out of your way not to get rekt by it
- DinaCoder99 3y agoEven checking the class of a given object feels quite flimsy to me, although this perhaps isn't a huge problem in a coherent codebase. This isn't meant to be an attack on javascript as a worthwhile tool to learn, by the way, just a testament to the fact that it's not an easy language to master in the slightest.
- jgilias 3y ago> but one that was meant to feel more like Java or JavaScript Those are two very different feelings though!
- pas 3y agocompared to Scala and TS they are the same 'ewww' :S
- yamrzou 3y agoTheir Hello, Dada! example: print("...").await I'm coming from Python, and I can't help but ask: If my goal as a programmer is to simply print to the console, why should I care about the await? This already starts with a non zero complexity and some cognitive load, like the `public static void main` from Java.
- baq 3y agoI'd say you want something like 'debug_msg()' for this. 'print()' should be async because it does IO. In the real world most likely you'd see the output once you yield.
- DinaCoder99 3y agoHuh, typically print is the debug message function vs explicitly writing to stdout
- dartos 3y agoI don’t think so. Normally print isn’t a debug message function, people just use it like that. (it normally works on non debug builds)
- couchand 3y agoPrinting directly to the console, even in a console app, is for debug purposes only. If your console app is writing output to any device, it must, for instance, handle errors gracefully. That means, at least in Rust, write! rather than print!.
- lkirkwood 3y agoWhat makes you say that? I almost always use println! over write!. From the docs: "Use println! only for the primary output of your program. Use eprintln! instead to print error and progress messages."
- Rucadi 3y agono upfront types, for me this is unusable sadly
- fweimer 3y agoGradual lifetimes could be interesting, though.
- leiroigh 3y ago^this! In garbage-collected languages, please give me gradual / optional annotations that permit deterministic fast freeing of temps, in code that opts in. Basically to relieve GC pressure, at some modest cost of programmer productivity. This unfortunately makes no sense for small bump-allocated objects in languages with relocating GC, say typical java objects. But it would make a lot of sense even in the JVM for safe eager deterministic release of my 50mb giant buffers. Another gradual lifetime example is https://cuda.juliagpu.org/stable/usage/memory/ https://cuda.juliagpu.org/stable/usage/memory/ -- GPU allocations are managed and garbage collected, but you can optionally `unsafe_free!` the most important ones, in order to reduce GC pressure (at significant safety cost, though!).
- diggan 3y agoLiterally every single program you ever created has needed types? I've probably written 100s of tiny little utility programs that are a couple of lines at most, and wouldn't need types for any of those, it would just add extra verbosity for no gain.
- Alifatisk 3y agoWhy the name and the logo? Couldn't find info about it. Otherwise, the idea of creating something close to rust but without the complexity sounds interesting. I just hope they don't stick to that name.
- yawpitch 3y agoThey’re both referencing the Dada artistic movement.
- Alifatisk 3y agoThx
- w-m 3y agoI was thoroughly confused reading the Dada Manifesto[0], starting with the non-existent German meanings of the word dada and getting much stranger from there. Until I found out at the very bottom that it's a riff on a 1916 dada manifesto. [0]: https://dada-lang.org/blog/manifesto https://dada-lang.org/blog/manifesto
- Schattenbaer 3y agoLogo might be inspired by Marcel Duchamp's _Bicycle Wheel_ see https://www.moma.org/collection/works/81631 https://www.moma.org/collection/works/81631
- brakmic 3y agoDada: https://en.wikipedia.org/wiki/Dada https://en.wikipedia.org/wiki/Dada
- bsimpson 3y agoVery cool art movement: it's essentially a prototypical form of Photoshop/meme culture as protest against the Nazis. John Heartfield is my favorite Dada artist. Perhaps his most famous piece is a photo of Hitler captioned "millions stand behind me," showing a donor passing him stacks of cash.
- VMG 3y agothe contrast of the links against the light background is pretty poor
- anentropic 3y agodon't know why you were down voted - this is totally correct, the site only looks right in dark mode
- happens 3y agoIt's weird, I want pretty much the exact opposite of this: a language with the expressive type system and syntax of rust, but with a garbage collector and a runtime at the cost performance. Basically go, but with rusts type system. I'm aware that there are a few languages that come close to this (crystal iirc), but in the end it's adoption and the ecosystem that keeps me from using them.
- sanderjd 3y agoTotally agree! But I think it's a "both and" rather than an "either or" situation. I can see why people are interested in the experiment in this article, and I think your and my interest in the other direction also makes sense.
- GardenLetter27 3y agoYeah, same for a scripting language too - something like Lua but as expressive as Rust. There is Rune, but like you mentioned the issue is adoption, etc.
- thegeekpirate 3y agoRight? One day... sigh
- quadrature 3y agoYou’ve just described scala.
- sanderjd 3y agoHa, no. Scala does contain this language the parent described, but alongside the huge multitudes of other languages it also contains.
- kaba0 3y agoScala is an absolutely small language. It is just very expressive, but its complexity is quite different than, say, Cpp’s, which has many features.
- emporas 3y agoThe absence of GC, makes embedded Rust a joy. It can be easily attached to other programs like Erlang with NIFs, Javascript and web pages with Web Assembly and Emacs with command line execution. Micro-controllers as well of course. I do consider the lightning start-up speed of a program to be one of the killer features of Rust. Rust with garbage collection throws away one of it's biggest advantages compared to every other language around.
- zem 3y agodon't think of it as rust with garbage collection, think of it as a GC language with features borrowed from rust
- mike_hearn 3y agoGarbage collection doesn't make program startup slow. Look at Go, or Java compiled with native-image.
- munificent 3y agoGC doesn't affect startup time. The slow startup you associate with GC language implementations like ones for Java and JavaScript mostly comes from JIT warmup.
- Doctor_Fegg 3y ago> What if we were making a language like Rust, but one that was meant to feel more like Java or JavaScript, and less like C++? That would be Swift? Interesting experiment. But it does seem like there are increasing numbers of languages trying to crowd into the same spaces.
- nu11ptr 3y agoYes, but languages don't compose well. For example, you can't take Swift because you like all the things the language does and then add in first class support for Linux and Windows. Thus, anytime a language doesn't align with EVERY thing you need it to do... a new language evolves.
- actionfromafar 3y agoWhat is Dada?
- m0llusk 3y agoexactly
- jokethrowaway 3y agoThe main idea is that leases are an easier concept to understand than borrowing and lifetimes? I don't think it will be, it sounds like a concept of similar complexity and it won't make it an "easy language". People are scared of Typescript, so a typed language with an extra ownership concept will sound exactly like rust in terms of difficulty. Not that I get the reputation of Rust being hard, even as a complete novice I was able to fight a bit with the compiler and get things working. The gradually typed approach is nice but it just sounds like smarter type inference would get you 99% there while keeping the performance (instead of using runtime checks). Not having unsafe code is both interesting and limiting. I keep all my code safe for my own mental sanity but sometimes having bindings to some big library in c/c++ is convenient (eg Qt or OpenCV).
- turnsout 3y agoYeah, it's not clear who this is for. If you can handle ownership, this doesn't seem to have many benefits over Rust. If you can't handle ownership, and don't mind a runtime, just use Swift, which seems to be the main inspiration for Dada's syntax.
- couchand 3y ago> As of right now, Dada doesn't really exist, though we have some experimental prototypes... > OK, from here on out I'm going to pretend that Dada really exists in its full glory. This is a brilliant trick I only recently discovered in another context: write the docs first, to validate the user experience of a novel system.
- Twirrim 3y agoDuring architectural reviews, I'm often the annoying person grilling the team on the customer experience. If you don't start from how the customer will interact with it, how are you going to create anything ergonomic? All too often, the engineering has started at "customers want to be able to do $x", and that's the last time the customer was part of the consideration. The solutions are great, but often miss out on what it'd be like to actually use it, as a customer. Lots of foot guns, and expectations of knowledge that a customer couldn't possibly have unless they had as much understanding of what happens under the hood as the engineers did, etc.
- alphazard 3y agoJust so everyone knows. Graydon is not in the list of contributors on GitHub. https://github.com/dada-lang/dada/graphs/contributors https://github.com/dada-lang/dada/graphs/contributors https://github.com/graydon https://github.com/graydon
- benrutter 3y agoI love the idea of a "thought experiment language" - actually creating a working language is a big overhead, and its really fun to think about what an ideal language might look like. The crazy thing with reading this and the comments, is that it seems like we all have been daydreaming about completely different versions of a "high level rust" and what that would look like. For me I'd just want a dynamic run time + simpler types (like "number" or a single string type), but it looks like other people have a completely different list. Some of the additions here, like a gradual type system, I would really not want in a language. I love gradual type system for stuff like Python, Typescript and Elixir, but those are cases where there's already so much untyped code written. I would way prefer the guarantees of a fully static typed codebase from day one when that's an option.
- brainzap 3y agoI agree, fantasy and play is needed. Since we humans have a brain area for play and imagination, why not explore.
- thesz 3y ago> actually creating a working language is a big overhead Languages, with first class values, pattern matching, rich types, type inference and even fancy RTS, often can be embedded in Haskell. For one example, it is very much possible to embed into Haskell a Rust-like language, even with borrow checking (which is type-checking time environment handling, much like linear logic). See [1], [2] and [3]. [1] http://blog.sigfpe.com/2009/02/beyond-monads.html [2] https://www.cs.tufts.edu/comp/150FP/archive/oleg-kiselyov/overlooked-objects.pdf [3] http://functorial.com/Embedding-a-Full-Linear-Lambda-Calculus-in-Haskell/linearlam.pdf Work in [3] can be expressed using results from [1] and [2], I cited [3] as an example of what proper type system can do. These results were available even before the work on Rust began. But, instead of embedding Rust-DSL into Haskell, authors of Rust preferred to implement Rust in OCaml. They do the same again.
- pas 3y ago> instead of embedding Rust-DSL into Haskell, authors of Rust preferred to implement Rust in OCaml why? and how much does it matter, if the goal is to have a compiler/interpreter? (as I assume is the case with Dada, and was with Rust)
- k__ 3y agoReminds me of Dyon, a scripting language for Piston. It's dynamically typed and uses lifetimes instead of a garbage collector. https://github.com/PistonDevelopers/dyon/issues/173 https://github.com/PistonDevelopers/dyon/issues/173
- imjonse 3y agoNot new, launched in 2021 apparently.
- luke-stanley 3y agoI was posting that "a_print" (an auto running async printer) might be better for one of the most common features a programmer uses. I'm coming from Python, and for situations when people grasp for C/++ kind of performance and control, I think people are aware of the need for high performance memory safe languages that are easier to use than Rust but with many of Rust's benefits being at least possible. So I am quite excited by thinking from Dada and the people who are behind Rust and I'm also intrigued by SerenityOS's Jakt language project. I hope the insecure "C code problem" has a smooth migration path that let's C/++ devs, Typescript devs, and others make progress quickly in a powerful way. What other sort of alternative languages are there, among Dada's aspirations? Jakt? Vale (I understand a lead dev is poorly, so it's slowed a bit lately)? D? Go? Obviously AI will have a big impact. What language is going to have a big impact in this space?
- nu11ptr 3y agoI like the idea, but please no "async/await". In a higher level language green threads like Go has are the correct answer IMO (and I'm not a Go fan, but I feel they got this part right). Gradual typing is interesting, but I wonder if necessary. Static typing doesn't have to feel like a burden and could make it hard to reason about performance. I think more type inference would be better than gradually typed (like OCaml/ML).
- jerf 3y ago"Gradual typing is interesting, but I wonder if necessary." Open question: Are there any languages that can be used in a (decent [1]) REPL, that are strongly typed, but do not have Hindley–Milner-based type inference? We have multiple concrete proofs that you can have a REPL with Hindley-Milner inference, but I'm curious if this is perhaps a concession to the difficulty of a strongly-typed REPL without a deeply inferable type system. But it's just an idle musing I'm throwing out to see the response to. [1]: That is, for example, multiple people have put a Go REPL together, but anyone who has used a "real" REPL from the likes of Lisp, Haskell, Erlang, O'Caml, Python, etc., will not find it a "decent" REPL, as Go just can't have one for various reasons.
- naasking 3y agoScala has a REPL. It uses HM, but has limitations on type inference due to subtyping.
- munificent 3y agoI'm not aware of any technical reasons why a given language would profoundly struggle to have a good REPL. I think it's mostly a matter of culture where REPLs aren't a priority in some language ecosystems because programmers there don't generally work that way.
- jerf 3y agoI'm not immediately aware of one either which is why I asked. HM does have its advantages but static languages are generally pretty clear on the type of an expression without annotations and just giving a variable the type of what it is set to achieves most of what you're looking for. It just occurred to me I couldn't name an instance of a static language without HM that does that, though. (At least I'm assuming LISP REPLs generally operate dynamically.)
- jamsterion 3y agoDada looks "almost" great! I especially like that it targets wasm; I believe wasm is the future of frontend and also backend with wasi. However, I believe that being gradually typed is a mistake. Dart started being optionally typed and then they made it fully statically typed for very good reasons. I hope they learn from Dart's experience there.
- color_me_not 3y agoI don't understand the comment in the method print_point in the class Point of the tutorial. [...] # This function is declared as `async` because it # awaits the result of print. async fn print_point(p) { # [...] print("The point is: {p}").await } [...] From the first page of the tutorial: > Dada, like JavaScript, is based exclusively on async-await. This means that operations that perform I/O, like print, don't execute immediately. Instead, they return a thunk, which is basically "code waiting to run" (but not running yet). The thunk doesn't execute until you await it by using the .await operation. So, what it boils down to is that async/await are like lazily computed values (they work a bit like the lazy/force keywords in Ocaml for instance, though async seems to be reserved for function declarations). If that is the case, that method "print_point" is forcing the call to print to get that thunk evaluated. Yet, the method itself is marked async, which means that it would be lazily evaluated? Would it be the same to define it as: fn print_point(p) { print("The point is: {p}") } If not, what is the meaning of the above? Or with various combinations of async/await in the signature & body? Are they ill-typed? I wish they'd provide a more thorough explanation of what await/async means here. Or maybe it is a dadaist[0] comment? [0] https://en.wikipedia.org/wiki/Dada https://en.wikipedia.org/wiki/Dada
- couchand 3y agoI suspect they're heavily relying on intuition coming from Rust, where both of those forms are okay. The one from TFA is sugar for your version. This works fine as long as there is only a single await point, otherwise you have to transform the syntax into a bind, which you might not be able to legally do manually (in Rust at least) if you hold a borrow across the await point.
- nialv7 3y agoI think they didn't do a very good job explaining it. Await doesn't just mean "please run this thunk", it means "I am not going to deal with this thunk, can someone come and take over, just give me the result in the end". What this means, concretely, in Rust, is `.await` will return the thunk to the caller, and the caller should resume the async function when the result is ready. Of course the caller can await again and push the responsibility further back. The most important thing here, is that `.await` yields the control of execution. Why does this matter? Because IO can block. If control wasn't given up, IO will block the whole program; if it is, then something else will have a chance to run while you wait.
- BobbyTables2 3y agoSounds a bit like Python but with actual & optional runtime type checking?
- richrichie 3y agoIt was only a matter of time before even the creators of Rust grew tired of it being another C++.
- sorenjan 3y agoChanging a quote to change "his" to "theirs" seem like a very Rust community thing to do. > Updated to use modern pronouns. https://dada-lang.org/docs/about/ https://dada-lang.org/docs/about/
- everybodyknows 3y agoOn iPad, I see a back-link from the footnote, but no forward link to it from the corrupted quotation.
- alphazard 3y agoI also noticed this, along with the warnings that Dada doesn't really exist yet (which is fine, thanks for the heads up). I predict this project will have its priorities backwards. There's a group of people who want to govern a programming language project, and inject their ideology into that structure, and maybe there's another group of avid language designers in there too. I think there are more of the first.
- herval 3y agoHow do you “inject ideology” in a programming language? Compiler error if the variable name is sexist?
- deleted 3y ago[deleted]
- alphazard 3y ago> How do you “inject ideology” in a programming language? I was just talking about the project community and governance. It would be hard to imagine injecting ideology into the language itself. Oh wait, nevermind... https://doc.rust-lang.org/beta/nightly-rustc/tidy/style/constant.PROBLEMATIC_CONSTS.html# https://doc.rust-lang.org/beta/nightly-rustc/tidy/style/cons...
- steveklabnik 3y ago
- talkingtab 3y agoMy opinionated opinion: programming languages have three goals. 1) Be safe, don't make mistakes 2) Be expressive: The Sapir Whorf hypothesis 3) Be easy to use. JavaScript (new) is +++2, and ++3 (to me). Java is +++1 & --2, -3. Personally I like OO ("has a") but think Class-ification,("is a") is a big mistake. Take a truck and a car. Start replacing the pieces of the car with pieces from the truck. When is a car not a car? Arbitrary. When does the car have a tail gate, a flat bed? That is not a joke. Classes and Types are a way to think (Sapir Whorf) that makes you do strange things. The interesting thing about Dada is the "borrow", "share" etc and seems very good. But then instead of wrapping it in a class can't we just use an Object?
- mihaic 3y agoI've written a bit of Rust, and I was left with mixed feelings, that seem to be still the same here: - loved the memory safety patterns when compared to the horrible things that you can do with C++ - found almost every thing where it was different to have a harder to parse syntax, that I could never get used to. The implicit return at the end of a statement for instance make it harder for me to visually parse what's being returned, since I really depend on that keyword. Code in general is hard for me to mentally read. I know it sounds nitpicky, but to me all keywords should be obviously pronounceable, so something like "func" instead of "fn" would be mandatory. Also, using the permission keywords where I'd expect the type to be also seems a bit strange, as I'd imagine that keyword to prefix the variable -- that's just how I think though. It does seem like less decorator magic and symbol-based syntax would make it easier for beginners to grasp. I may sound like a curmudgeon, but I'd prefer only one type of language innovation at a time.
- haswell 3y agoI’m in the middle of working through The Rust Book, and I haven’t written any serious code with it yet, so interpret this through that lens. When I looked at rust code before, it all seemed a bit weird. I couldn’t immediately understand it, but I’ve since come to realize this was because the dozen or so languages I can read well don’t really resemble rust, so my pattern matching was a bit off. The more I learn about the syntax and core concepts, the more I’m learning that my brain absolutely loves it. Once I started to understand matches, lifetime syntax and the core borrowing mechanics, things clicked and I’m more excited about writing code than I’ve been since I taught myself GW-BASIC 25 years ago. Just sharing this anecdote because I find it interesting how differently people experience languages. I also have an ongoing friendly debate with a friend who absolutely hates Python, while I rather enjoy it. I’ve tried to understand why he hates it, and he’s tried to understand why I like it. And it all seems to come down to hard-to-define things that just rub us in different ways. I hope the benefits of rust find their way into more types of languages in the future.
- mihaic 3y agoYeah, I think at some point we all have some internal wiring that is hard to change, while other parts are flexible. For instance, I'm fine to write C++, Javascript or Python (with types at least). Ruby or Rust for some reason do rub me the wrong way, no matter how much I try to tough it out.
- udev4096 3y agoNot this again. How many languages do we need? I am having a good time with Go and Python!
- Georgelemental 3y agoSee also Graydon Hoare's Rust-that-could-have-been: https://graydon2.dreamwidth.org/307291.html https://graydon2.dreamwidth.org/307291.html
- pxeger1 3y agoI think there isn't enough research into languages with affine/linear typing (the property of some types that they can't be copied - which is partly what the borrow checker ensures in Rust). I'm super sold on it for enhancing safety. Vale with its "Higher RAII"[0] is the only other example I was aware of until seeing this. Rust is great but being an early adopter has made its usability imperfect in places. Combining substructural typing with gradual typing and OOP is interesting here. Others in this thread have also mentioned wanting a higher-level Rust, like Go. I'd like to see a purely functional Rust. Haskell has experimental support for linear typing[1], but I suspect a language built with it from the ground up would be very different. [0]: https://verdagon.dev/blog/higher-raii-7drl https://verdagon.dev/blog/higher-raii-7drl [1]: https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/linear_types.html https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/line...
- magnio 3y agoHave you look at Austral?[0] It is a system language with affine type as the main selling point. I really, really like its specifications, in particular the design goals and rationale. [0]: https://austral-lang.org/ https://austral-lang.org/ [1]: https://austral-lang.org/spec/spec.html#goals https://austral-lang.org/spec/spec.html#goals
- ubj 3y agoInteresting, but the intent seems similar to Chris Lattner's new Mojo language which arguably has similar characteristics and is further along in its development. https://docs.modular.com/mojo/ https://docs.modular.com/mojo/
- deleted 3y ago[deleted]
- melodyogonna 3y agoMojo but for Javascript
- stephen 3y agoIf you're cloning parts of TypeScript, please bring along mapped & conditional types! Feel free to experiment on the syntax, but the concept is amazing, especially if you're planning on being dynamic-ish.
- p0w3n3d 3y agoIt sounds like mockups to create a programming language
- greenie_beans 3y agolove this quote > I speak only of myself since I do not wish to convince, I have no right to drag others into my river, I oblige no one to follow me and everybody practices their art their own way. > Tristan Tzara, "Dada Manifesto 1918”
- snarfy 3y agoIt's a bit frustrating that I have to click around hunting for an example of the syntax. If you are making a new programming language, please do us a favor and put your Hello World syntax example right on the landing page.
- platz 3y agoI thought the docs themselves were a work of conceptual art i.e. the docs themselves were "dadaist" and were the main point of the site
- kkukshtel 3y agoFeel like there would be fewer posts and languages like this if people just took 10 seconds to read about modern C#.
- iopq 3y agoIf only it played well with Linux, but Mono is always playing catch-up
- lpribis 3y agoThe latest dotnet plays reasonably well with Linux and supports latest framework and language version.
- kkukshtel 3y agoFeel like there would be fewer posts and languages like this if people just took 10 seconds to read about modern C#
- neonsunset 3y ago`sudo apt-get install dotnet-sdk-8.0` I wonder what that does...
- hgs3 3y agoI've dabbled in PL research before, and not to downplay the work as this is just my opinion, but the Rust ownership system is too invasive. It prevents entire classes of architectures and algorithms from being directly represented without auxiliary structures and other code contortions. I don't think it is an approach that should be mimicked.
- zozbot234 3y agoThe Rust ownership system was built to be compositional - an architecture or algorithm must not just be "safe" in isolation, it must also preserve that safety when interacting with the rest of the system, even as either part gets modified or evolves further. Practically speaking, this is where many proposed architectures that may indeed appear "safe" run into issues. (If you can't provide these guarantees, the idiomatic approach in Rust is to isolate that part within an unsafe module, and document the expectations that said module imposes wrt. the rest of the system.)
- zubairq 3y agoAmazing way to test if a new computer language is viable! I think that more people (including myself) should take this approach to language design.
- sn9 3y agoThis might be a naive question, but rather than targeting WASM directly, why not target MLIR (used by projects like Mojo) and use LLVM to compile to WASM?
- librasteve 3y ago++ that gradual types are included … Rust does an awesome job of the contract you want with your compiler is enforce types strongly for maximum safety, but this is not always the appropriate trade off for small projects … i prefer a language with a sliding scale where i can grow a codebase and be more strict if and when it becomes more mission critical (gradual typing is the answer for this imo and is well done in eg rakulang)
- sagebird 3y agoInteresting. The about page starts with a quote from Dada Manifesto 1918. The quote is changed, as explained in a footnote: "Updated to use modern pronouns." Here is the original quote: I speak only of myself since I do not wish to convince, I have no right to drag others into my river, I oblige no one to follow me and everybody practices his art in his own way, if be knows the joy that rises like arrows to the astral layers, or that other joy that goes down into the mines of corpse-flowers and fertile spasms. changed to : I speak only of myself since I do not wish to convince, I have no right to drag others into my river, I oblige no one to follow me and everybody practices their art their own way. dada-lang about: https://dada-lang.org/docs/about/ https://dada-lang.org/docs/about/ Tzara, Dada Manifesto 1918: https://writing.upenn.edu/library/Tzara_Dada-Manifesto_1918.pdf https://writing.upenn.edu/library/Tzara_Dada-Manifesto_1918....
- helothereycomb 3y agohttps://antelang.org/ https://antelang.org/