seiji

Did it?

For simplicity, http://deis.io should be preferred for modern "deploy-by-buildpack" architectures.

But, "practical" doesn't show up on everybody's radar much these days with so much effort focused around fads-of-the-half-decade.

Erlang is made by professionals with decades of experience who grow the system towards being the most stable, scalable, safe, and as understandable as possible. People use Erlang, solve problems, stay quiet, then make money using it.

On the other hand, the thought leader these days seems to be Go (even though it's made by out of touch weirdos (review: http://www.evanmiller.org/four-days-of-go.html)) and has a creepy cult/fanatical following more suited to tribal sportsball teams than what we would expect from professional technical work needing to be stable over the long term.

Lisp doesn't actually exist. Lisp is just axioms. You run an implementation of Lisp allowing various operations. Some flavors actually have (practically) zero mutability. You just create functions and cons cells and the rest of the world gets built on top of those.

But, pure functional systems are useless (to be purely functional would mean you can't even do I/O... your program would just heat up the computer, which, in a way, is its own form of output, so you can't ever be fully functional).

Every functional language gets non-functional at some point for data processing, bootstrapping, loading/saving programs, and the best functional languages even have optional mutability constructs for performance (see: !). You can't create the most performant data structures possible if all your operations require path copying, but mutability should be reserved for internal high performance library creation and avoided in business logic/application level code to make systems easier to reason about.

The whole "apply" stage is probably just because it's a new service. Don't want to have 10,000 people jumping on your as-yet-unproven process without a gating mechanism.

Most law enforcement officers actually hate the law and just want "privacy APIs" for everything so they don't have to think about how searches/seizures/privacy all works together.

Both systems are ways to get you bootstrapped as quickly as possible, but you should always lawyer up to verify the rest. The clerkly offerings go a bit deeper into employment/contracts, and Stripe could actually knock those out too by adding just a few more template forms over the next few months.

(not affiliated with either, just keeping up with the quickest/easiest/legalist ways to start organizations as hassle free as possible)

The most amazing this here is obviously the automatic bank account integration. The last time I set up a SVB account I had to drive to their Santa Clara office, meet someone, convince them I'm not a hack fraud (lol, tricked them on that one), then fax over paperwork, then wait a week for things to get enabled. Just a lot of friction before even getting started on the real goal of setting up a business account for accepting iOS platform payments. (side note: let's hope the SVB web interface has gotten better since then. last I checked, it felt like a scaled up 1996 web app... kinda awful all over, but it got the job done.)

This offering does sound like it's more focused on helping non-US people to just start processing US payments easier and not expressly around startups (a la clerkly). It skips some startup-isms we all know and love (83b forms not expressly mentioned, does it allocate "startup levels" of default stock during incorporation, etc), and a big thing not mentioned: it doesn't register you as a foreign entity in a non-delaware state. You'll get a nastygram from your state tax office if you don't register as a local foreign entity (they'll scrape IRS details about you to figure out which companies exist in their state but aren't registered). Registering as a foreign entity is different for every state (more fees) and sometimes more BS ("you must notify the public of your new corporation by paying for notices in two (2) newspapers for six (6) weeks to complete this process" (that could be just for actual corporations and not foreign registrations though)).

Looks like an amazing offering overall, and it's always amusing to see how AWS throws credits all over the place. If Google could wise up to it (assuming it's not an Amazon promotional exclusivity contract), they should be throwing 4x-10x AWS-sized credits at all the same targets too.

Or we can just store everything as int64_t natively anyway. It's only 8 bytes after all (and storage is big these days).

These can also have the "avoid 10 bytes" optimization by just reading the next 8 bytes exactly if the first byte is just all ones (no need for a zero separator; it would be in the way and push out the final bit to its own isolated byte again).

Get back to us when you have an algorithm for love and art and petrichor.

Fun facts: those are commonly known as "vbytes." They are the slowest kind of variable width integer encoding. The simplest (naive, and generally considered "wrong") implementations of variable-width-by-continuation-bits uses 10 bytes maximum. A proper implementation uses 9 bytes maximum.

There's actually no reason to ever use 10 bytes in this encoding. If you use 10 bytes, that means your last byte only holds one bit of actual user data. That's not very cool. But, your next-to-last byte holds seven bits of user data and one bit of metadata. We can easily say "if we're at the next to last byte, don't use metadata, just use all the bits we need." All you have to do is say "if we are currently at 9 bytes, don't use a 10th byte, just use this 9th byte directly." bam. Your 9th byte now has 8 bits of user data and you don't roll over a useless 10th byte with one bit of data.

The "slide all continuation bits into the first byte" sounds like a trick, but it's really using a TLV encoding where the first byte just holds a number between 1 and 8, so the entire integer+metadata is now [1 type byte][1 to 8 user data] = 2 to 9 bytes total. Using this scheme also kills any "1 byte, standalone, variable width integer" capability (unless you're storing partial values in the first T/L byte, but then that limits you to a much lower max value for one byte).

So is working on antigravity, free energy, and backwards time travel, but people don't do that because they are no reasonable approaches we can try.

Glorifying "AI AI AI" is silly because — there are no approaches we can try. Sure, we can identify ten million images per second, but none of that involves the least bit of "thinking."

If you have enough users to have "too many issues to handle," then you're big enough that you need an official governance and contribution structure. You're also big enough where you'll have a pool of high quality contributors to promote to project-level-oversight status.

Nobody is saying "do all this work for free forever," but people are saying: "You have too much work you're avoiding. Why refuse to let other people help?" Once you reach a million users this isn't your private software anymore, it belongs to the community and you need to step up and allow faster development than one person can handle alone.

Of course you can put anything you want up online (and you should!). But, if you have (or expect to have) millions of users, then one person sitting alone saying "ME ME ME" doesn't cut it.

It stops being less about fun when your company loses $10,000 per minute of downtime and you suffer an outage because you are operating "at-scale" (256 GB RAM to 1 TB RAM, thousands of clustered servers, multi-datacenter replication, etc) but your software is only tested on the primary developer's macbook air.

Rejecting the feedback of people with actual experience running large scale systems in favor of one person's unexperienced narrow viewpoints is just bananas. Large scale software can't operate under single minded "open source fascism" anymore because our computing world is too complicated these days.

With millions of users you'll have people using your software for critical systems needing things like uptime, reliability, timely security fixes, timely bug fixes, etc. When you start getting 50 requests a day for changes, you will seem inept just telling everyone "lol its my software i do whatever i want you should just go away and fork it you can't tell me what to do."

It's professionally irresponsible to run a project with millions of users without a scalable team of equal contributors.

The argument against companies running their systems on top of poorly maintained/developed/supported open source software (while still expecting free and immediate improvements/fixes) is an entirely different article though.

It's 2016 and you can't run an (intended) global-scale open source project by just being "code nerd in chief." If you can't run an open feedback-driven community and if you can't be chief architect (also means communicating plans constantly, not just 'do whatever you want') and if you don't possess technical and professional excellence (also means being responsible with security issues and timely resolving of user issues), then you don't actually have an "open source project," you have a private uploaded code repository other people can see publicly.

Gone are the days of 1995 when you could live on an island and upload your new code once per year and everybody would leave you alone and praise you in computing magazines for being a genius. Now you'll have 1,000 issues on GitHub and requests for public appearances and proposals for changes and important security flaws to fix and requests for extensive communication about current designs and upcoming features.

The whole "i'm going to do this all on my own, everybody else go away it's my code" doesn't work anymore. Those projects are now destined to fail on their own without open and scalable community leadership. The good projects "get it" and the old guard are toppling as we speak. In another two years, nobody will trust open source projects without a stated scalable community model and codified successorship plan.

Startups?

how these assholes seize power. It's through charismatic promises of future rewards

Startups.

GitHub raised $250 million last year and, as you mentioned, there's nothing externally visible to show for it (as consumers of their public platform). (random guess: the $250 million could have been $150-$200 million in cashing out stock to individuals (like crooked groupon shenanigans) then maybe $50 million for operations? How many billions of dollars does it take to write an issue tracker with more features than redmine from ten years ago?)

Same comments were making the rounds months ago too: https://news.ycombinator.com/item?id=10165681#up_10166913

All this gets back to a bigger trend we see these days: closed platforms are like governments (google, apple, github, twitter). We don't allow (sane, first-world) governments to exist without citizen representation. We must demand user-level representation in corporations running global scale closed platforms everybody relies on. Community powered social platforms don't exist without the community, and private corporations exercising extended "we don't give a crap about the users even though we have millions (or hundreds of millions) of them" patterns must be... corrected.

No Computation Without Representation.

~1500 years ago: desire is the root cause of suffering.

If you're in the "2 year old with unlimited power" camp, nothing can save us and everything is futile and we should all just eat drink and be merry for tomorrow the AI kills us all.

If you're in the AI-as-enlighened-buddha camp, the godlike AI will either save us all — or — just leave us alone to solve our own problems (while potentially locking out future godlike-AI development so we don't do too much runaway damage (eschaton, etc)).

Well, consider having a 360º array of 30 cameras all integrated into a perfect spherical sensory experience. It's something we can't really imagine experiencing natively, but it would be trivial for eBrains to coalesce visual systems that way from eBirth.

Our bodies have lots of low bitrate sensors like billions of individual sensory nerves distributed throughout our bodes (and they are each individually addressable in the brain), but we don't think of "touch" as a sense to "computationalize" like vision or sound or language.

One amusing thing about AI sensors: nobody ever talks about superhuman smell. Where are the quantum AI noses?

That's one of the best analogies we've got with regard to "deep learning" versus reality. People around here seem to think the AI apocalypse is 3-5 years away and are rushing to fund billion dollar "sentient rock" research.

Just for fun, add !kEDH to your server's list of allowed cyphers then see how your performance changes.

Another performance impact some people overlook: your key size is also computationally expensive. There's not much reason to have a key larger than 2048 bits, so if you made a 4096 bit key just for fun, roll it back to a 2048 bit key for better performance too (plus, your mobile viewers will thank you for not burning their battery life needlessly).

Plus, https://angel.co/laundry-1

Not sure how that's the watch's fault?

I don’t suppose to take off my watch every night and charge it!

That's kinda part of the deal.

the sport band, which doesn’t make it easier to take the Watch off and put it back on.

But, it does. For putting it on you just have to brace it against something else to hold it in place. A couple practice times gets it down pretty good. For taking it off, it's basically a pull tab. Can't be much easier than that.

It's a physical watch, not our abstract lord and savior we can offload all subjectivity onto to make us feel better about ourselves.

keep telling myself it’s the best watch ever designed…

Just wait until it's also the key to your Apple Car.

In some ways it seems all the "regular" people get absorbed into other levels of success/purpose outside of technology here, so technology is left with a larger weirdo population than SF since there are many more non-techonlogy things to make regular people happy around here.

Iterating those concepts don't seem to fix the issue of Twitter running 50,000 copies of an application developed by 3 open source volunteer people and not paying those 3 people anything.

That's actually a great idea and almost impossible to make reliable.

We could measure "stack risk" for registered, 100% above board companies with their own data centers and employees, but we can't really measure the risk of some guy in eastern europe with access to a 1 billion node, globally distributed and illegal obtained, Android bot net.