I wonder if it's possible to create a streamlined platform for this kind of work. Like others mentioned being able to start at an outline stage and then move on to fleshing the parts out would be interesting. I could see the outline being its own repo and each "unit"(probably chapters) get their own repo and maintainer. Nightly builds could be conducted to merge the work in the repos into a coherent whole, reconciling missing parts with their outline bullet points. An interface over the "build" to make quick commits and PRs would be nice too.
Additionally a community style guide and "story bible" would probably be in order. I believe a lot of writing projects which involve a large number of writers like video games and TV series do things like this. On an unrelated note, are there any tools to enforce natural language writing style compliance? Like code linters for human text?
Wow, as someone that switches between two language inputs(coincidentally English/Japanese actually) a lot on a variety of OS's, and never uses caps lock, I think this is a great key-binding.
This is a bit of tangent, but I looked up Idris since I'd never heard of it. I'm currently learning Haskell and they look really similar. What differentiates the two? What can you do in one that you can't do in the other?
As practical matter, Idris is a new experimental language while Haskell is a mature, stable language with a useful standard library.
But fundamentally Idris is theoretically more advanced than Haskell. The core differences are
1. Idris functions can be proven to terminate (if you choose).
2. In Idris, types are first class values, and you can have dependent functions: functions whose return type depends on their input value.
An example of something you can do in Idris and not* in Haskell, in Idris you can define a vector type Vect n a, which is the type of vectors of length n with values in type a. You can also define Fin n, the set of integers less than n. Then you can define a function index : Fin n -> (Vect n a) -> a which takes an integer less than n, a vector of length n with element of type a, and returns an element of type a. This function is guaranteed to return a value, because the index is guaranteed to be in the correct range.
*For some meaning of "not": you can probably do this in some way in Haskell.
Yeah, you can definitely do that example in Haskell – if by Haskell you mean GHC. GHC has been slowly but surely adding dependently-typed features for quite some time now, which will culminate in a proper DependentTypes pragma sometime soon (for some meaning of soon, anyway).
There are a lot of other differences between Haskell and Idris, though. Totality is a pretty big thing, and Idris is also strict by default. It also has support for proof tactics, which I don't see Haskell getting anytime soon.
I'm not an expert, but I wouldn't think so. To me, full dependent types just means you have pi and sigma types. I don't see anything fundamental about pi and sigma types that would prevent you from having bottom in your language, or from allowing users to define partial functions.
Yes, it happens at compile time. To understand how proofs work here, you want to look at the Curry-Howard correspondence. Basically, there's a correspondence between types and propositions, and between the values inhabiting those types and proofs of the corresponding propositions. So a proof looks like a value of a certain type.
And it's equally possible to interpret this data positively. Perhaps VCs are becoming more selective and concentrating their money on better teams/ideas instead of casting as wide of a net as possible(I am not saying this is actually the case).
I don't understand why so many journalists try to find catastrophe in the absence of contrary evidence.
What's the financial outlook for this career path? I've always heard bad stories about early hires dealing with a below market salary(for a while) with worthless stock options. Is this a myth? It never made sense to me since I feel an early hire should make significantly more than average, since they don't have the power/equity advantage of a founder, probably have to work long hours, and a large part of the success of the company rides on their shoulders.
I think even before you bring responsibility into the picture, there's a lot for each actor in this situation to gain from reestablishing communications(I certainly can't see what they would lose, except for face). This is assuming the other party is mature and rational though.
For Clojure there's a plugin(albeit a very big plugin) over IntelliJ IDEA, called Cursive that I've heard a lot of nice things about: https://cursiveclojure.com/
Additionally a community style guide and "story bible" would probably be in order. I believe a lot of writing projects which involve a large number of writers like video games and TV series do things like this. On an unrelated note, are there any tools to enforce natural language writing style compliance? Like code linters for human text?