It's almost entirely down to the pedigree of the people asking for money. And pedigree boils down to education and/or previous wins.
It's been one of the most basic tenants at ycombinator from the early days:
> In fact, we're so sure the founders are more important than the initial idea that we're going to try something new this funding cycle. We're going to let people apply with no idea at all. If you want, you can answer the question on the application form that asks what you're going to do with "We have no idea." If you seem really good we'll accept you anyway.
I worked with a recent (at the time) Stanford grad who had applied and been selected for one of the early ycombinator cohorts. Paul didn't like his group's idea, and told them to walk around the block and come up with something better and then pitch it to him. The pervading philosophy for many investors is that the idea is less important than the team, at least in the initial investment.
>Opera did try to some interesting features such as "Unite" which -- if you squint a certain way -- was a form of p2p decentralization. Yes, it's interesting to have a built-in web server in the browser but not enough people cared about it.
Unite is a typical example of something that worked fine and disappear all the same. I haven't find any browser that surpass Opera 12 to this day. All the new "exciting stuff" are no use to me. I don't want to adapt to my browser, I want a browser that adapt to me.
It's kind of fun, speculating about the interaction between medium and style. Like, that there's something about human minds and a grid of squares that leads to certain things that ~work~ and feel good, regardless of whether that grid was created by the warp and weft of woven cloth or an electronic bitmap.
We independently reinvented an adaptation of this algorithm for Monte's "simple" quasiliteral, which does simple string interpolation and matching. The code at https://github.com/monte-language/typhon/blob/master/mast/pr... is somewhat similar in appearance and structure to the examples in the post.
def name := "Hackernews"
# greeting == "Hi Hackernews!"
def greeting := `Hi $name!`
# language == "Lojban"
def `@language is awesome` := "Lojban is awesome"
A quirk of our presentation is that adjacent zero-or-more patterns degenerate, with each subsequent pattern matching the empty string. This mirrors the observation in the post that some systems can coalesce adjacent stars without changing the semantics:
# one == "", two == "cool"
def `adjacent @one@two patterns` := "adjacent cool patterns"
False positives suck. There are people coming on here day after day, posting valuable or at least worthy comments, and nobody can see them. They waste their time unknowingly. It is cruel.
E and Monte have safe eval() as a consequence of being object-based capability-safe languages; there's no way to cause any effect outside eval() worse than an infinite loop.
To the second part of your question: as you have undoubtedly noticed, you've never heard of E nor Monte.
Hi, compiler author here. You're not being downvoted for your POV, but because you're not grokking that the thing that you are asking for is fundamentally difficult.
Nearly all serious compilers have at least one representation which is not isomorphic for all programs. (It is homomorphic, which is required for the compiler to be correct.) As a consequence, at least some programs will be mangled beyond recognition.
Just because it's hard doesn't mean it isn't worthwhile to do, or that everything the compiler does must be reserved and shown in the IDE. I'm also not suggesting that this compiler feedback is the only IDE improvement we make. I'm observing that the entire way we develop software hasn't fundamentally changed in decades, yet every other aspect of computing has. Even something that roughly seems the same like word processing is now collaborative and in the cloud with real-time updates and social threads.
Light table is one IDE that is trying to question some assumptions -- like that files are important and that everything must be 1 line spaces apart in mono font. This is the kind of progress I'd like to see.
It does seem reasonable that there be a way, even if difficult, to highlight a bounds check that gets optimized away. If we start from the problem we're trying to solve (show eliminated code that poses security risks... such as bounds checks or erasing memory) rather than the general problem (reverse all compiler changes), then things become more tractable.
If you convince people that science is true or real not by logic, but by rhetorical tricks, then you are no longer peddling truth; you are blindly proclaiming that science is the only correct epistemology.
I hate to be mean but the reason argumentation isn't always about facts is because there's the written (most formal) and the spoken (most informal). Along that spectrum you can be as rigorous as a mathematical proof to being fast and loose with emotive appeals with your arguments. But what's important to take home with this idea is that you construct a logically valid and sound argument that's easy to digest but also emotionally comprehensible. Otherwise, you're going to lose your audience. For example, Vox ran a video on renewable energy from a person who is a conservative (part of the Tea Party movement and supported/advocated-for Donald Trump). She pointed out that to get conservatives on the side of mitigating climate change with adopting renewable energy we have to ditch the climate change rhetoric. We have to go for what drives conservatives: competition, cheaper energy, and energy independence. Oddly enough, this holds true back in my home state with Governor Brownback (who I despise) because he's gone against the Kochs with respect to adopting/advocating wind power. Now the wind farms are growing and making a profit for Westar and other power companies in the state. Basically, when trying to convince to an audience you have to know that audience.
The meaning of "Quantum" is a bit confusing. I thought it was only Servo ports, but after I read your post I looked around and found this. I guess it's any improvement to Gecko?
"Quantum has a number of components, including several adopted from the Servo project."
Quantum is the umbrella, if you will, under which a bunch of performance focused subprojects are being developed. Some of them (Quantum Render, Quantum CSS) are importing Servo components (WebRender and Stylo, respectively), while others (Quantum DOM, Quantum Compositor, Quantum Flow) are serious surgery on existing Gecko components.
"Secure", as a word, does not make things secure. "Container", as a word, also does not make things secure.
Sandboxes come in two flavors: Correct by construction, and exploitable. Which flavor is this system?
What makes this better than NixOS? Than Genode? Than Qubes? Where is the actual security writeup? Where's the explanation of the security model for the system? How would I write code which takes advantage of structural security in the system?
In short, to answer my earlier questions, the sandboxing is undocumented, comparisons to other security-oriented setups are omitted, the limit of structural security is OCaml's type system... This seems like an interesting effort but I am disappointed that it seems more like lip service than an attempt to actually improve on the state of security design.
This misguided blogger thinks that object-based programming is necessarily about members and inheritance. It isn't. It's about message-passing and uniform interfaces and bundles of state and behavior. It's about ravioli code and modules and separation of concerns.
... Alan Key, who coined the term "Object Oriented Programing" identified the following his definition of "object oriented":
"OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme LateBinding of all things."
Alan Key though Java and C++ were abominations. However he may feel, THAT is the state of Object Oriented Programming today. Objects are instances of classes, which typically also determine their type. :/
There's an entire branch of the Smalltalk family with no classes, just prototypes, with Self, Python, JS, etc. and there's another branch without prototypes or classes, with E, Monte, etc.
You're not wrong that Erlang and Scheme are just as much about objects and message-passing as they are about actors.
Kay may or may not agree with me, but I like to require a facet he mentioned in another discussion once: The uniform calling interface. This is the property of objects that you may send any message to any object. If you require this, then Java and C++ disqualify themselves neatly.
There are "Blub" languages which are such that if you don't use inheritance to connect two record types T1 and T2, either to a common supertype S, or to each other, then T1 and T2 are not substitutable. The users of these languages came up with the term "object based" for that situation in order to try to linguistically connect that to object-oriented programming somehow.
In real OOP, we don't have to use inheritance for objects of different types to be substitutable, so "object based" doesn't exist as a separate phenomenon. We use inheritance when two or more things are internally similar, such that they can share a chunk of implementation. If things are similar only externally (API level) but have totally different internals, then we don't use inheritance.
OOP is happening when we substitute objects of different types into the same code and they work, regardless of whether those objects are related to each other by inheritance.
"Object based" is when we cannot do that.
It's basically a new (or not so new any more) term for "abstract data type" which is used when the abstract data type language supports obj.function(arg) syntactic sugar.
If we take Wirth's Modula-2 or Pascal exactly as-is (two languages exemplifying abstract data typing support) and then add the "obj.function(arg)" sugar, they suddenly become "object based".
I don't understand how "only a vague idea" is able to raise millions of dollars in the first place. Can you elaborate or give an example?