131–140 of 182 posts
Rust with lisp syntax. Like what this macro does https://github.com/JunSuzukiJapan/macro-lisp Wait maybe what I want already exists
‘Growing a Language’ and the ‘Are We There Yet’ presentations changed the way I look at languages, so right now I would say my “perfect” high-level PL would be a Java-like language (possibly running on the JVM due to ecosystem-reuse and the killer GCs and performance) where immutable “objects”/values are the first-class citizens, but method implementations can use local, mutable semantics. I would also very much add…
* Java-like language
* immutable “objects”/values are the first-class citizens
* method implementations can use local, mutable semantics (including mutable captures)
The one that would allow a domain specialist to skip all the dev/build-ops and wheel-research into a project structure and jump straight into a business logic. Akin to what excel is to users, ignoring its clumsy parts in this analogy. To name a few details: Rich but plain standard library with convenience features. E.g. if you have to read json file, you just readJsonFile(filename), not sys.fs.readFile(fn, “a”, {enco…
I do like the idea of a better dev ops system. Maybe with better github workflow integration or a custom git frontend? Then everything would be coupled together a bit tighter with the advantage of an ergonomic, uniform interface to do your devops
> I believe that the purpose of life is, at least in part, to be happy. Based on this belief, Ruby is designed to make programming not only easy but also fun.
Writing Ruby code feels natural, from creating classes, all the way to its basic types. Knowing everything is an Object makes it easy to work with.
The tooling is amazing as well, from managing gems through bundler, and running simple scripts such as rake tasks.
Now, if it's performance can be further improved, say like Go-like speeds then it would be further used.
* C/C++ core made more multi-paradigm in the spirit of Mozart/Oz.
* The runtime semantics of Erlang and BEAM VM.
So it would be a set of DSLs (one per paradigm but the ability to work together) with a common core of modified C/C++ like syntax and the ability to run on top Erlang BEAM VM with its guarantees. I think it is fully doable today and will eat the World.
‘Growing a Language’ and the ‘Are We There Yet’ presentations changed the way I look at languages, so right now I would say my “perfect” high-level PL would be a Java-like language (possibly running on the JVM due to ecosystem-reuse and the killer GCs and performance) where immutable “objects”/values are the first-class citizens, but method implementations can use local, mutable semantics. I would also very much add…
Hm, a weaker type system? I dont really see much of a point in that, though type inference is quite good
I’m quite okay with e.g. Haskell’s type system up to a point (including monads), but some even more exotic feature and borderline dependent types are not something I would put into the language (I will let other languages be the testing grounds for these ideas!), as I think that most interesting properties will not be provable either way and that a constrain-based approach may scale better.
Python, but with static typing and compiled to native code. I love Python's syntax. It's usage of whitespace forces people to have some semblance of proper formatting. Overall, I find Python code extremely easy to read. But my god is it slow, and I've always assumed a lot of its slowness is due to being interpreted and the duck typing.
Being interpreted definitely, even though there are some rarely-used methods that can improve that. Additionally, there are more than one implementations of Python, and pypy is much faster than the standard CPython.
As for duck typing, why would that make a language slower exactly?
- One executable that is the runtime, accepting one argument: the source code file. - No linters. Code is auto-formatted. - No modules. Includes can be namespaced/aliased. - No package manager. Include by Git URL with tags. - No type annotations. Automatic type-checking. - No user-defined types. A few good types is better. - No null. Set membership with maps is better. - No exceptions. - No loops. List and map compre…
Can you elaborate on the no higher order functions, and the no modules but namespaces part?
No modules / namespaced includes means that to include other code, you would write something like `include as Foo './other-source-code.file'` or `include as Bar 'github.com/foo/bar/some/source.file@commit`. All the names in the included file (functions, names of data, etc.) would be referenced by prefixing the namespace, like `Foo.baz` or `Bar.baz`. Combine that with the ability to include code via URL, and there would be need for a package manager or separate package manifest. Wherever you want to use the new version/code you simply update the include statement at the top of the file.