1,035 karma · joined February 12, 2012
More seriously, I am really following this project closely, and now that it's open source I'd like to see if its possible to add the key libraries my field needs: mathpartir, and something like semantics? especially if typst can provide better syntax and errors!
Proof overhead for memory safety can frequently be on the order of 5-10 lines of annotation per line of code.
I do think however that (safe) Rust can be said to have mutable value semantics, if you forget what a borrow “is” you find yourself exactly with a value-oriented language.
These languages bring a lot of key guarantees that you can't (easily) get from more classical languages like bounded memory usage, hard real time guarantees, numerical properties, ability to prove theoretical properties about the model etc...
It's also not like having your code written as a text file would save you from using closed source proprietary compilers or languages (Ada, Ferrocene, various C distributions) for safety-critical software.
To give an idea of the scale involved, Voyager 1 is only 0.058% of the way to the nearest star system, and that took 45 years. Granted it wasn't built for speed but given that the best hypothetical plans for a spaceship we have allow travel at ~.1c it'll take 50 years not counting acceleration / deceleration.
> Eventually probe will find planet with life. May be life is more abundant than we imagine now. May be not. Surely there will be protocols for the probe to investigate life. It's hard to imagine what those protocols would be. May be explore freely until certain technology advances are observed and then hide.
Even assuming that some set of automated probes have been travelling our galaxy for millions of years, and reached earth in the last few thousand years, where are they now? By what mechanism could they even be hiding? Every inch of the planet is being watched by satellites.
> My point is that developed civilization inevitably will expand its sphere of influence at speed limited by speed of light. Probably slower than that. But billion of years at 0.1c is still huge chunk of universe.
As an aside, I'm not sure you could meaningfully have one civilization spanning hundreds of millions of light years, the ends are just too spread out for there to be a single cohesive or web of cultures. Imagine if an email took longer than our entire species existence to reach you.
> Are we sure that no civilization born within this radius billion years ago?
I personally am certain that there are many other forms of life throughout our galaxy, and at least some of them must be technological. As much as would like for it to be false, I also believe there is no realistic mechanism for travel between stars and we are all effectively doomed to stay in our little corner of creation, maybe spying on each other through telescopes, assuming we can even spot a neighbor.
I don't DF would have existed then, it would be hard to see it gather the same community and the creators probably wouldn't have felt as free to explore their own ideas if they felt it needed to be commercially viable.
The thing that made DF's current commercial success is it's previously un-commercial approach. It's a true labor of love and that shows in every aspect of the game.
:)
It doesn’t solve attribution, and you could get a sufficiently advanced ai to “launder” copyright but at least it would prevent those corporations from leveraging public works into copyrighted projects
* Parser generator grammars are usually quite far from 'paper' versions of a formal grammar. The moment you have to deal with associativity/precedence or left-recursive rules the beautiful grammar tends to fall apart.
In theory most generators have mechanisms to help make this ergonomic but irl most grammars I've seen are totally illegible.
* Error messages suck. I think this is actually a bigger issue, but parser generators have pretty poor error messages compared to even naive recursive descent parsers written with a library like megaparsec. There has been research on generating better error messages in generated parsers like menhir [1], but I haven't seen anyone apply this successfully and it requires you to manually annotate each error state with a message, and a real parser can easily have thousands, and they can change each time you update your grammar.
* Parser files are usually fairly illegible because they mix host language code with parser syntax and meta-variables. Some more modern libraries like Pest separate the two which I think is a net improvement.
Nevertheless, I hope that someone figures out a way to square the circle and frees us from handwriting parsers in all but the most exceptional cases.Depending on what you want to achieve there are plenty of tricks and techniques to encode a divergent program in a sound dependent-type theory, but the best approach to use will depend on the problem statement.
Long story short, these languages are based on the “Howard-Curry isomorphism” which says that we can view type signatures as theorems and programs with that signature proofs of that theorem.
A program which runs forever is a proof of false (you could see it as saying “after infinity time I’ll have your answer I swear”). So these languages are designed to prevent that from being possible.
The issue is that I imagine that just keeping an idle natural gas generator large enough for your pipeline + shipping terminal + whatever is not a trivial cost.
let a = if cond {
1
} else {
1.0
};
a + 3
Now, the error would be pushed to the `+` operator because there isn't an `Add` for `f32 | u32`. Granted, this is a trivial example, and a programmer can easily see through it, but in general this can get very overwhelming and cause errors to leave their 'root cause'.The reason it's so important is that inlining synergises with other optimizations, its often run before or after other passes like constant propagation. Consider something like:
fn add(x : usize, y : usize) -> usize { x + y }
fn main() {
add(5, 1)
}
Without inlining we can't easily optimize the code of `main`. However, if we inline `add` into main, constant propagation will then directly see `5 + 1` and optimize that into `6`.If some billionaire wanted to 'move the needle' and change society for the better I think building a truly better latex would be worth it. Each year some of the most brilliant people in the world sacrifice on the altar of latex, that could instead be spent on more productive research.
I recently tried helping my aunt switch internet providers to one 50% cheaper, I called, set everything up, it was all finalized they just needed to come switch the connection over. After I left, she made a call to the company to switch the appointment and ended up getting the contract cancelled, then stuck in limbo and a month later I still haven’t been able to get it fixed. It’s impressive how if someone doesn’t know the right phrases and things to say, you end up in digital purgatory where no one can help you.
I'm using the Latex and LatexTools packagest, so I don't follow your point. It's pretty good and can also be set up to properly autocomplete `\cite` and `\ref` in multi-file projects quite easily.
Cool to see community listed as a feature up there with the tech stuff
=== START OF SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED
SMART/Health Information (NVMe Log 0x02)
Critical Warning: 0x00
Temperature: 28 Celsius
Available Spare: 100%
Available Spare Threshold: 99%
Percentage Used: 0%
Data Units Read: 14,683,648 [7.51 TB]
Data Units Written: 15,448,997 [7.90 TB]
Host Read Commands: 198,962,886
Host Write Commands: 199,550,695
Controller Busy Time: 0
Power Cycles: 172
Power On Hours: 196
Unsafe Shutdowns: 15
Media and Data Integrity Errors: 0
Error Information Log Entries: 0fwiw, I TA a course taught (partially) in OCaml and work regularly with a large OCaml project as part of my thesis.
Parser generator errors are just a personal pet peeve of mine, I grew up with (mega)parsec (Haskell), where decent errors are out-of-the-box and great ones are easy.
> Syntax errors are caught well by the parser which tells you exactly where they are.
They aren't necessarily caused where the actual error is, just wherever the parser gets stuck, and the error it produces is usually not reflective of the human thought process that went in, but rather the automata's state.
- Dependency management, despite progress `opam` is hopeless brittle because no one uses lock files, good luck building a project that's more than 3 months old. Additionally, by default everything is installed into a global 'switch' and only one version of each package can exist in it.
- Build tooling: things are finally improving with `dune`, but the amount of packages that are running hyper-complex Makefile based build systems is incredibly frustrating. It can be very difficult to add a dependency or change the layout of these projects if you aren't an expert in arcane Make sigils.
- Error messages: again, finally improving, but the number of times I've gotten errors like "line 78 Syntax Error"... I know that parser generators are appealing academically / intellectually but there's a reason major industrial compilers use recursive descent.
- Documentation: Seemingly non-existent for most packages and the tooling is quite poor compared to peer languages (Haskell, Rust).
- More controversially, I think that modules are a worse solution in practice than typeclasses / traits. The automatic instance resolution coherence brings is a huge ergonomics win, and it also allows for more ecosystem wide collaboration in practice. I know that modular implicits are supposed to bring the 'best of both' but that doesn't even exist yet.
None of the problems above are unfixable but they collaborate to make working in OCaml a very frustrating experience for me, even worse because through them I can see what is actually a quite nice language.
tiny nit, but INRIA is not a university but rather a national network of labs.