Thanks for the tip, will update the language to clarify.
610 karma · joined September 5, 2013
Follow me on X [2]
[1] http://ultralig.ht
[2] http://x.com/adamjsimmons
- https://ultralig.ht/screen1.png
- https://ultralig.ht/screen2.png
- https://ultralig.ht/screen3.png
And yes, the renderer is completely new, this project has been in development for 4+ years.
I've personally used it for improving some distance-field approximation code on the GPU (made it easier to translate the math into numerically-stable code).
I do a lot of procedural graphics on the GPU and am constantly plagued by precision issues (you cannot copy equations verbatim into code, you must observe overflow/underflow and other numerical issues). Herbie is pretty magical in that it can _automatically_ translate math expressions into a form that's friendlier for computers.
Also the reason why the GitHub site source was linked is because the website [1] crashed under traffic earlier today (full site contains an interactive solver and examples).
Sad to see you felt I had zero empathy to your plight, a full refund was approved just weeks after your license purchase.
PS. for anyone reading, if you love UI and got a C++ or C# background, we're hiring! Email me at adam@awesomium.com
For what it's worth, we have made huge progress on R&D these past 20 months and will be announcing the fully redesigned 2.0 soon. (And you can be damned sure we will be onboarding more customer support in preparation for the next product cycle)
Excellent points regarding the exceptional breadth of requirements necessary to effect change.
I don't think this precludes my earlier belief concerning individual responsibility for our collective progress. This is a conversation that everyone needs to participate in precisely because there is such a rare chance any one individual will have the necessary pre-requisites to take action.
Even the most plebian among us may one day find themselves flush with cash, and when they do, they could wield those resources responsibly. The concept of "noblesse oblige" (or, the more modern Spider-Man variant: "with great power comes great responsibility") comes into mind here. Interestingly, Elon made a veiled reference to this shared outlook in his "sinking ship" metaphor recently on Colbert.
I too was deeply troubled by Notch's attitude toward unwanted success (and more importantly, the worrying precedent it sets for others). It's disappointing that he has no apparent desire to utilize his position in a useful manner but I wonder how much of that mindset is a product of our current environment.
So, where is the Elon Musk of high-energy physics? Where is the Elon Musk of terraforming, both off-planet and on Earth to reverse climate change? What of cancer, antibiotics, longevity treatment, machine intelligence? Et cetera
At the risk of sounding rather trite: the next Elon Musk might be reading this page right now.
Elon is not an island. He had to have gotten his attitudes from somewhere. Teaching kids about our shared responsibility and to dream big about real problems is an act that every adult can (and should) participate in. Those who are in a position to mentor or inspire another (even if it's a boss to an employee, VC to a founder, or friend to friend) should also take part.
Though I call into question whether or not that responsibility (to coordinate action towards the advancement of human civilization) should be left solely with our heroes. I believe this narrative will never truly change until every individual takes some share in that responsibility.
I actually see plenty of ambition in the valley and elsewhere— ambition to be the next billion-dollar success story.
What I don't see is a lot of purpose-consciousness + ambition. It's been offered that the purpose of all for-profit companies is to make money; any venture intending to create value for anything but its shareholders is therefore a non-profit.
I think this is wrong. For-profit companies can work toward a clear, common goal without sacrificing profit. I think the modern web (which was built by contributions from hundreds of companies) is a great example of this. SpaceX and Boeing (funded jointly by NASA) working in tandem to enable private space travel is another.
I have often wondered what made the West so great during its golden age of innovation (and to answer what we're missing today) and think it can be attributed to a single-mindedness in our culture and leadership towards a common goal.
The Industrial Revolution (and American Revolution) would not have been possible without the overwhelmingly popular Age of Enlightenment (a cultural movement of intellectual reform that emphasized reason over tradition). Such multi-national cooperation and exchange of ideas had been previously unprecedented. The intellectuals of each country banded together because they had a common enemy (entrenched tradition, religion, and monarchy).
Similar patterns (large-scale cooperation towards a common goal) can be found in the Second Industrial Revolution, the Atomic Age, and the Space Race.
So the question remains: what singular goal(s) do we have today?
The Internet has a great deal of potential to be used as a vehicle for a new intellectual revolution that may drive a new age of progress. I've seen a few hints of this in the OSS community and Silicon Valley but so far neither have found a common goal that resonates strongly enough.
tl;dr : The want of progress is not specific enough to inspire. We need a new, overarching goal to drive the next age of progress.
Seems they use the bitcoin block chain heavily as the basis for trust and security. Both of their "proof of burn" and "proof of timelock" techniques require each user to have a complete copy of the latest block chain (currently >20GB) to independently verify global trust.
I mention a few other pitfalls with this approach in another comment [2].
Using the block chain as a single, shared, decentralized database is an interesting solution but has serious flaws when used as you describe:
1. Transactions are not added immediately (and by added, I mean a consensus has been reached by a majority of the network on the state of the block chain), it can take up to 10 minutes for confirmation to be reached [1] with modern networks and hardware.
2. Each transaction increases the size of the block chain. To independently verify a transaction, each node must have a complete copy of the block chain which is about 21 GB today [2], and growing ~1 GB per month. This rate is expected to increase with time which presents one of the biggest flaws of Bitcoin today. Several strategies exist to reduce the size (pruning of the data, using lightweight clients that only store headers instead of full data) but all of these reduce the ability for an individual node to verify a transaction.
3. Transactions can fail for various reasons: data is too large, transaction fee too low, fork in the blockchain, orphaned blocks, etc. What's even worse is that you won't know (and can't try submitting the transaction again) until confirmation fails ~10 minutes later.
4. Transactions fees for storing arbitrary data in the block chain is dependent upon the real-world price of bitcoin. What's more, once the block reward approaches zero (the reward is cut in half approx. every four years) the rewards of mining will shift entirely to voluntary transaction fees. This will likely cause transaction fees to increase.
5. The block chain is only secure as long as there doesn't exist a single group with a majority of processing power (it is kept in check by competition between miners). If a monopoly develops it can abuse the system very readily.
These various reasons (latency, size, failure, fee increases over time) make the block chain a pretty bad back-end for the implementation of a shared, decentralized database of a real-time P2P app.
The idea isn't completely unsalvageable however, another way of looking at the problem is to realize that the block chain file itself is used as a shared resource between many "threads". Each thread has its own local copy but reconciliation must be performed across all threads to ensure consistent state (which introduces huge amounts of synchronization and contention).
To parallelize the problem, we must reduce the amount of resource contention required. The best way to do that is to use separate databases (eg, separate block chains) for separate, logical clusters of threads. Eg, for a ridesharing app, you can use a separate database (block chain) for each city. This way, only the data that is relevant to each thread must be synchronized.
There's a few problems with this approach (could allow local monopolies to develop more readily) as well but it better emulates natural models for decentralized systems.
It might also be better to use a hybrid approach based on the type of data involved:
1. Use a secure DHT (distributed hash table) to store data that isn't necessarily transactional (such as individual ratings that could be aggregated via an unstructured query).
2. Use a local block chain to synchronize shared resources (such as driver availability).
Save/Export doesn't seem to work on my machine (Chrome 37, Mac OSX).
Would be nice to see some kind of SVG export instead of raster formats.
When I request a ride, the _system_ gives me...
Think of the "system" as a large crowd of people in a room. Only certain people in the room have the information you want. It is totally unfeasible to ask every person in the room, you can only ask the three guys closest to you.
What do you do?
The best strategy to maximize query performance mimics the real-world— each person occasionally gossips information to each other, which replicates data across a network and increases the chance that someone nearby will have the answer you seek.
The problem then comes down to trust-- say you ask three guys nearby a question: "Do you know if there are any cabs nearby?"
Let's say those three guys did happen to know of a cab nearby but wanted it for themselves (they just got an invite to this AWESOME party in the Haight), so they lie to you and take the cab for themselves.
Or, in an alternative case— they are all three sons of a rather horrible cab driver and tell you that he is the ONLY one available.
If we had a global view of the system, the chances of this abuse might be minimized but this is just not feasible in real-world implementations.
There's also other implications for privacy (nodes in the middle might log your queries) which might also introduce new vectors for abuse.
- Every node is potentially untrustworthy therefore additional verification must be performed on the results of any query. To verify a piece of information, a "paper trail" must be transmitted as well (who created what when).
- This overhead causes information to move much more slowly in a system (if at all, if the threshold is set too high it's possible for all queries to fail).
- To counter this cost, each node can build its own map of trusted nodes based on the validity of previous information. This "network of trust" can be used to throttle the amount of verification performed.
- To illustrate, let's take what happens if you're totally new to a fully decentralized ridesharing platform. You start off not knowing any of the other users (nodes) and so you select a few at random (trusting all mutually), perform a query on all nodes and select the driver with the best rating (according to popular rating from those few users). You take a ride from that driver, have an awful experience, and therefore don't trust the ratings shared by those users anymore. You're back to square one. Building trust takes a lot of time and first-hand validation.
- There's potential for trusted nodes to turn "bad" (untrustworthy) therefore each node must continuously "police" neighboring nodes and relay any changes in behavior to mutually-trusted nodes.
- What's more, there is a certain "cost of competition" that comes with truly decentralized systems. You cannot roll out "system-wide" changes as easily as a centralized one since a majority of the system must first agree (and many times that majority is too small to even consider it a consensus, which ends in grid-lock).
- These five costs (paper-trail, verification, building network of trust, policing network of trust, cost of competition) makes the overall performance of a distributed platform very inferior to that of a centralized platform like Uber.
- Of course there are downsides to centralized platforms like Uber. The quality of ratings is less trustworthy since all users use separate criteria (and could be untrustworthy Lyft proponents). Also, Uber (as a system) does not make decisions in the best interest of its users and is only kept in check by its competition (which is diminishing each day).
- You can look to human civilization as a way to illustrate some of the challenges and solutions of purely decentralized systems. It would be pretty hard to survive if everyone didn't trust anyone outside of himself. We built our own networks of trust via our family and friends (our tribe). As human populations grew, so too did competition between tribes. Centralized governments and services were then built to offset some of our individual responsibilities and promote unimpeded, fair flow of certain resources while still preserving those aspects that benefit the most from decentralization.
- These hybrid systems (platforms with both decentralized AND centralized aspects) work the best in the real world as long as those centralized parts keep working for the majority of nodes and a healthy balance of decentralized/centralized is maintained. (You'll notice we struggle with both of those caveats today in modern civilization).
Whoo! Sorry for the long-winded post, I have a lot more to say on the subject but I'll save the rest for a blog post :). (I'm working on decentralized authority and identification in my spare time so this is a hot area of research for me!).
1. Use SWIG [1] to generate the C-API from the C++ headers (you are limited to a subset of C++: no STL, no templates, all interfaces must be pure-virtual).
2. The guys behind Mono created an amazing tool [2] that allowed you to call C++ symbols directly from managed C# code via transparent translation of the underlying ABI scheme (automatically maps the object layout, vtable layout, and name mangling scheme and emits code at runtime). They finished the GCC ABI and added partial support for MSVC ABI. Sadly the project seems to be abandoned in recent months.
I think this would be super-convenient in the short-term but seems very worrisome in the long-term. My watch/phone/drivers-license is NOT me, and the more we rely on a single-point for authentication, the greater the potential for abuse and theft. More solutions need to be created.
It's been a decade so my memory is a bit fuzzy, but here's what I remember about that time:
We started with AEGIS (leaked Korean server files) on the asb-sakray board [1] but it was notoriously hard to setup since it had major MSSQL and ODBC driver dependencies (I wrote guides). We started work on an installer for Aegis but realized we wanted to customize the server even more.
A few emulators started to take hold at this time (YARE probably the biggest) but Gravity (creator of RO) threatened legal action and shut it down.
Enter "Athena"— we discovered a Japanese RO server emulation project on the "Avethes" BBS that had the most complete packet mapping at the time. AppleGirl did most of the first translation of the code (AppleMod) which spawned a ton of other English emulation forks as the YARE developers jumped back on.
It was a really fun time for me— age 14, not much programming experience, in the middle of this massive, open-source MMORPG emulation war. I learned so much about C++, network programming, and server architecture during that time (as did many others). All the different forks openly stole code and ideas from each other so things moved very quickly.
The beautiful thing about writing code for RO private servers was the immediate sense of gratification you got. I could implement a small change to a skill, or a new NPC behavior, and then immediately log into the client and see it in action (and then thousands of users would see it in action when we committed the change).
We weren't concerned so much about code quality in the beginning since Athena strived to be a server modder's paradise— if you wanted raw stability, you went with Aegis instead. Stability came later once all the projects eventually aligned under one flag (eAthena).
I left in 2005 to work on server emulators for Lineage II, and later got bored of servers and jumped to client-side graphics programming, where I've been happily working for the last seven years. (Funny enough, my latest project [2] was used in Lineage II as well as hundreds of other MMOs and games, so I've now written code for both emulators and official. :))