HNHacker News
TopNewBestAskShowJobs

brandur

3,383 karma · joined August 30, 2011

APIs + engineering @ River. Ex-Snowflake. Ex-Stripe. Ex-Heroku.

Twitter: https://twitter.com/brandur

GitHub: https://github.com/brandur

Website: https://brandur.org

Email: brandur@brandur.org

submissionscomments
brandur··on A Berlin Borough Buying Out Private Landlords
> The US owes it's "walkability" or lack of due to Blockbusting by property developers in the 50s that used racism to drive the middle classes out of the cities into the newly built suburbs. No such thing happened anywhere else.

I think that might've been a factor, but it's an overgeneralization. In Canada, we didn't those race relations problems to anywhere close to the same degree, and yet big Canadian cities are just as sprawled as their American counterparts.

For my money, the major problem with the US and Canada is for the most part, we got to start fresh. A lot of the expansion happened in the age of the automobile, and at the time, we built what we thought we wanted — large suburbs and big arteries to take us between them. This worked pretty well in the beginning, but the further we spread, the more obvious the realization that the design doesn't scale [1].

In Europe, a lot of cities were built pre-car, and although they've seen significant change in the interim, large parts of the original geography are left over. There are some places that consciously designed their infrastructure well even if it was against the grain for the time (e.g. anti-car protests in the Netherlands that led to modern bicycle-friendly Amsterdam; also, Copenhagen), but a lot of it is a historical accident which turns out to have led to better livability than anything our city planners have done on purpose in 100 years.

---

[1] It's still not obvious to everyone, but as commute times continue to go up, I believe that broader consensus will form.

brandur··on The Equifax breach may be the worst leak of personal info ever
I don't think Have I been Pwned will be of much use unless Troy's able to get a dump of the leaked information from somewhere.
brandur··on The Marketing Behind MongoDB
> As a new grad I often times find myself frustrated with setting up postgres or other rdbms so I usually opt for easier systems like amazon RDS, firebase or mongo.

Yeah, I know exactly what you mean. Everything in Postgres is supremely well documented, but there's just so much documentation, that getting the basics down is pretty hard. I definitely went through a period of building muscle that was a tad frustrating to say the least.

Unfortunately, I don't know a particularly succinct resource that I recommend right now, but I will suggest taking a look at official docs. Maybe the section on managing databases in particular [1]. In general, you should just get good at using createdb, dropdb, and psql (which is mostly just generic SQL).

If you're on a Mac, installation and setup might looks as easy as:

    brew install postgresql
    brew services start postgresql
    createdb my-test-db
    psql my-test-db
    dropdb my-test-db
(There's obviously far more there than just that, but at a basic level, most of the commands are reasonably easy to use.)

[1] https://www.postgresql.org/docs/9.6/static/managing-database...

brandur··on The Marketing Behind MongoDB
> I think the most interesting question though is would they be able to get MVP and initial customers that set off this if they were moving (slightly) slower due to SQL and slight overhead that comes with?

I've used Postgres and Mongo pretty extensively, and for any reasonably seasoned developer, the startup overhead of an SQL system is a myth. There may upfront cost to learning how an RDMS and SQL work in the first place, but once you're familiar with them, they'll be faster than Mongo on any new project.

The schemaless concept of a document database seems to be the major selling factor in velocity of movement, but once you've got a good handle on a migration framework in the vein of ActiveRecord or other popular software, that's negated completely. It also really doesn't take long before schemaless starts to cause big problems for you in terms of data consistency -- it's not just the big players that get bitten by this.

The simplified query language is another one. SQL is a little bit obtuse, but it's not that bad once you have a handle on it, and a lot of people are familiar with it. Once you add in an ORM layer, the lazy-style access of a framework like Sequel or SQLAlchemy makes the developer experience quite a bit better than any Mongo APIs that I've seen. Also, after you get beyond trivial usage, SQL's flexibility so wildly outstrips Mongo's query documents that it's not even worth talking about.

Postgres on the other hand ships with a great management CLI, a very powerful REPL (psql), and features like data types/constraints/transactions that guarantee you correctness with zero effort on your part. I can only speak for myself, but I'd take Postgres to the hackathon any day of the week.

brandur··on The Limits of Copy-On-write: How Ruby Allocates Memory
Fascinating — I had no idea the technique had a name (the Ruby source isn't very heavy on comments). I'll update the article to include it.
brandur··on The Limits of Copy-On-write: How Ruby Allocates Memory
I wrote this one. I've been working with Ruby roughly six years, but didn't understand its memory internals at all beyond the surface level until I started doing the research for this one.

If there's one takeway/point of interest that I'd recommend looking at, it's the novel way that Ruby shares a pointer value between actual pointers to memory and special "immediate" values that simply occupy the pointer value itself [1]. For example, a fixnum (most integers) has its binary value shifted by one bit to the left, and then a "1" flag applied in its rightmost position so that Ruby can recognize it. It doesn't have to go to heap, and the runtime can take advantage of that for faster calculations.

[1] https://brandur.org/ruby-memory#value

brandur··on Ask HN: What to do when Slack gets too disruptive?
Your best bet might be to be less responsive on Slack — not only by not responding to everyone immediately, but by not responding to some Slack messages at all. If it's important, the person who pinged you can submit their request via another medium, hopefully in a longer form format like email or bug report that's more thoughtfully considered and thoroughly researched, and which you can reply/fix quickly without spending 10 to 30 minutes of your work day in tight synchronous communication.

It's sort of a bad thing to do, but you will start getting fewer Slack messages. People have an implicit understanding of who's likely to respond in a timely manner, and somewhat ironically, it's the most responsive people who have to improve their responsiveness even more because by being responsive they'll get even more messages and interruptions.

On a meta note, it continues to surprise me that more people and companies aren't talking about the highly distracting effects of the software. It works great at small scale, but if you get large enough everyone's pinging everyone all the time. I recently read Deep Work by Cal Newport (excellent book by the way [1]) and couldn't help but being mildly entertained when they get into the time draining effects of email (it seems to have been written a little before Slack caught on). The distraction engine created by Slack is the SR-71's Pratt & Whitney J58 [2] compared to email's 5 HP motor out of an everyday golf cart.

[1] https://www.amazon.com/Deep-Work-Focused-Success-Distracted/...

[2] https://en.wikipedia.org/wiki/Pratt_%26_Whitney_J58

brandur··on How Postgres Makes Transactions Atomic
Author here with just a quick note that writing this was a pretty great learning experience. Postgres has always been the ultimate black box — it does some amazing things, but I generally have no idea how.

I read a lot of Postgres code to get this finished, and I'm happy to say that for a codebase with so many authors, the quality of Postgres' is very high. Like any complex program it can be a little hard to trace through, but most of the naming is pretty self-explanatory, and it comes with some really amazing comments that walk you through the high-level design. I'd definitely recommend taking a look if anyone is curious.

brandur··on Ask HN: Potentially Moving to SF / SV with a Family
As an SF resident of ~5 years, I agree with this.

$130k - $150k isn't really big money around here. You'll be able to live, but I suspect that you'll start to feel pretty quickly that your quality of life has been overall compromised since leaving Ohio. Real estate is the biggest expense — a $3k apartment won't even be a nice one, but you'll feel it everywhere — expensive meals, goods, lots of taxes, etc.

Long term prospects for property aren't great either. Property prices have been trending for a while in only one direction (straight up) and properties that would be considered very modestly nice in other cities are easy $1M+ in and around SF. Real estate agents play bidding games so everything goes for well above listing prices. NIMBY practices and regressive taxation laws (Prop 13) guarantee this isn't going to be fixed anytime soon.

As someone with a daughter, it's also worth considering that the public schooling system is in a pretty bad state. It seems that almost everyone will either use private if they can afford it, or move out to Marin or the South Bay so that their kids can go to a functional school. Don't take my word for it though, I have lots of anecdotes, but have never needed to seriously look into it, so do your own research.

Another big factor to consider is just the city itself, and how nice it is to be here. A combination of huge wealth disparity, unaffordable real estate/rent, poor treatment for the mentally ill, and moderate weather means that the number of deranged people that you'll meet on the streets and public transportation is way above average. Property crime is essentially rampant at this point (mostly in the form of smashed car windows and bike theft), and the police force is quite ineffective, so I don't expect that to go anywhere but up. If you're a reasonably sized guy it's all mostly tolerable (in that you don't really fear for your well being), but I'm not sure it's an environment that I'd want to raise children in. As far as I can tell, a lot of other industry workers just seem to take Uber/Lyft everywhere to avoid it.

All that said — SF is a fun city, and the nature around it is beautiful. It's one of the very few walkable/bikable cities in North America, which is great. As a tech person, it's also neat to be right in the thick of things.

brandur··on Airbnb dominated by professional landlords
Sure, AirBnB certainly isn't the only cause of rising rents in Berlin. The city's become an incredibly attractive place to be over the last decade, and that's almost certainly the foremost reason for rent increases.

But AirBnB is contributing something to those rising rents, and unlike the desirability of your city, it's something that you can control for.

I (along with probably most people that share a similar position) would argue that regulating AirBnB is good, but not adequate. Pretty much every large urban development in the world (SF, London, NY, Berlin, HK, etc.) is experiencing the same problem that because they're desirable they're also automatically unaffordable. We need to figure out how to put roofs over people's heads by building much more, and much more cheaply.

brandur··on Airbnb dominated by professional landlords
> That, presumably, is one reason supply is restricted ("fixed")

(I'm the grandparent.) Yes, this. I'm all for new construction to improve supply and a streamlined bureaucratic process so that it can happen more quickly.

Practically speaking though, you can look at any city that's had a problem with AirBnB (Berlin, San Francisco, New York, Barcelona, etc. — pretty much anywhere desirable to visit) and new stock isn't coming online anywhere close to quickly enough to counteract the market forces introduced by AirBnB. As it stands today, building is a very slow process, and it's likely to remain that way for the foreseeable future.

brandur··on Airbnb dominated by professional landlords
I think it's stated quite clearly in the article, but although professional landlords might be fine for AirBnB tenants (and obviously good for the landlords themselves), they're bad for cities and their residents:

> Berlin, like most German cities, is experiencing an acute shortage of affordable homes. Rents are rising at a rate of nearly 10 percent a year, even though the city has a rent cap and has introduced one of the strictest bans on holiday apartments - many other European cities also have some kind of regulation.

The problem with housing is that the supply is very fixed. A unit that's taken off the market to become a full time AirBnB is one that's not available as a rental for a resident of the city anymore.

There's an argument to be made for private property rights, but the further trouble with real estate is that it's often made as an investment, and like other capital, it tends to be reallocated disproportionately over time.

While it might seem obvious for someone to be able to rent out their vacation home part time, it's much less so that an owner of 15 units in downtown San Francisco should be able to hire a property manager and rent them all on AirBnB full time — given a sufficiently enticing city for business/tourism, eventually there won't be enough stock for the locals anymore (or more accurately, the upwards pressure on price will make it unaffordable for nearly everyone).

brandur··on There are very few suitable use cases for DynamoDB
I've seen two large usages of DynamoDB at two different companies, and for what it's worth, in both cases we've had similar trouble as the author. In one case we ended up ripping it out and moving to a sharded Postgres scheme, and in the other we've left in place for now because a migration will be such a monumental effort, but it's pretty much universally maligned.

Fundamentally, the problem seems to be that choosing a partitioning key that's appropriate for DynamoDB's operational properties is ... unlikely. In their own docs on choosing a partition key [1] they use "user ID" as an example of one with good uniformity, but in reality if you choose something like that, you're probably about to be in for a world of pain: in many systems big users can be 7+ orders of magnitude bigger than small users, so what initially looked like a respectable partitioning key turns out to be very lopsided.

As mentioned in the article, you can then try to increase throughput, but you won't have enough control over the newly provisioned capacity to really address the problem. You can massively overprovision, but then you're paying for a lot of capacity that's sitting idle, and even then sometimes it's not enough.

Your best bet is probably to choose a partition key that's perfectly uniformly distributed (like a random ID), but at that point you're designing your product around DynamoDB rather than vice versa, and you should probably wonder why you're not looking at alternatives.

---

[1] http://docs.aws.amazon.com/amazondynamodb/latest/developergu...

brandur··on Cicada – Unix shell written in Rust
Here's a very simple example that I'd consider the holy grail. Say I want run `ls -lh` on a directory:

    -rw-r--r--   1 brandur  staff   6.5K Mar 25 15:37 Makefile
    -rw-r--r--   1 brandur  staff    63B Jul 10  2016 Procfile
    -rw-r--r--   1 brandur  staff   1.6K Mar 11 07:20 README.md
    drwxr-xr-x   4 brandur  staff   136B Oct 16  2016 assets/
    drwxr-xr-x   4 brandur  staff   136B Jul 15  2016 atom/
    drwxr-xr-x   4 brandur  staff   136B Apr 26  2016 cmd/
I'm interested in getting the date fields out of this structure. Currently that's possible with some disgusting use of `awk` or maybe `cut`.

What if I could do something like `ls -lh | select 6` (select the 6th column of data):

    Mar 25 15:37
    Jul 10  2016
    Mar 11 07:20
    Oct 16  2016
    Jul 15  2016
    Apr 26  2016
It doesn't matter that the date comes in three parts and would act as three separate tokens for `awk` and `cut` because in my structured object backend, it's all just one logical timestamp.

Now say I want to sort these dates and pick the earliest. Once again, shells make this extremely difficult. Because the dates are not lexigraphically orderable, I'd have to use some fancy parsing, or try to step back to `ls` and have it somehow order by date.

Imagine if I could instead to something like `ls -lh | select 6 | sort | first`:

    Apr 26  2016
In this case, although the shell is still displaying a string to me that's not lexigraphically orderable, the data is being passed around in the backend in a structured way and these timestamps are actually real timestamps. It's then trivial for the next utility to apply ordering.

The part that the shell would have to provide (as opposed to the programs) is a "smart pipe" that understands more than just a basic text stream. It would also have to know when there is no pipe connected, and print as pretty strings when it knows the output is going to `STDOUT`.

brandur··on Cicada – Unix shell written in Rust
Amazing work! Between this, Alacritty [1], and coreutils [2], we're getting pretty close to a plausible all-Rust CLI stack.

While Cicada is pretty clearly modeled on the "old" generation of shells (sh, Bash, Zsh, etc.), one has to wonder what a more modern shell might look to address some of the problems of its predecessors like pipes that are essentially text-only, poor composability (see `cut` or `xargs`), and terribly obscure syntax.

PowerShell seems to have been a flop outside of the Windows ecosystem, and between overly elaborate syntax and COM baggage, was probably rightfully passed over, but it probably had the right idea. Imagine a future where we're piping structured objects between programs, scripting in a modern language, and have IntelliSense quality auto-completion for every command.

---

[1] https://github.com/jwilm/alacritty

[2] https://github.com/uutils/coreutils

brandur··on Introduction to MongoDB
> And many of us aren't working with relational data.

I think this is probably where the disconnect is. If your data has relations to other data, which is the vast majority of things that you're going to be building in the real world, it's relational.

Mongo came out of the gates billing itself as a general purpose backend solution for modern "webscale" apps. It was upfront about being document-oriented, but not upfront about the ramifications of such a design, leaving a lot of people including the author of this article to find out the hard way as to the sort of architectural debt that you end up with as you shoehorn a relational schema into a non-relational store.

When you're showing a simple demo with three relations like article <-> comment <-> user it's easy to be fooled that a document oriented design is relatively sane, but once you build something more complex the shortcomings become very apparent _very_ quickly.

> That is exactly what it was designed to be and one of the big reasons people are using it.

A lot of people are using it because of early hype, aggressive marketing (the "MEAN stack"), and misleading benchmarks when it came out (`writeConcern`, flush intervals, and no journaling) combined with the fact that moving databases is very hard once you've got a big operation going.

I don't think there's been a reason to use Mongo for years now, but that goes doubly so these days with the advent of modern scalable databases that give you a lot of important features that Mongo doesn't (Aurora, Citus, Spanner, ...).

brandur··on Introduction to MongoDB
> I wouldn't post this in the future. It's irrelevant.

> This is pre-Wiredtiger which means it is a completely different database.

That's not true. Mongo switched out their backend and fixed a few heinous bugs and defaults. All the important parts from the perspective of developer and operator experience including no data normalization, weak constraints, lack of anything beyond document-level atomicity, etc., are still the same.

If you read the article, it's largely about how document databases that encourage denormalization don't do a good job of modeling or working with relational data, which is most of what we're all working with. In this respect, nothing's changed in Mongo.

brandur··on Toronto eyes plan to crack down on Airbnb-style rentals
> The solution to the "Airbnb problem" of rising home costs is less regulation, not more.

Regulation around short term rentals and regulation around construction and zoning are two very different things. I agree that every city can probably benefit from more progressive construction policy, but that doesn't mean that restricting short term rentals isn't also a good idea.

It's nice to think that the free market combined with liberal policies will produce so much capacity that all problems around pricing (and by extension AirBnB) will be solved, but we haven't seen much evidence that this can occur in a timely enough manner to come anywhere close to meeting demand, which may also be increasing over that time. Here in San Francisco for example, we've seen a massive construction boom over the last few years, but it's having no effect on prices because even though thousands of new units are coming online, the pent up demand still vastly exceeds the new supply.

Even assuming you could solve the problem with construction, the solution will come on a decade scale whereas AirBnB can entire change the face of a city's rental market in a few years, or less (take a Berlin for example). Popular cities would still need restrictions on AirBnBs to keep the problem in check until longer term increases in housing capacity can be put in place.

brandur··on Citus 6.2: Concurrent index creation and complex queries for multi-tenant dbs
This is a pretty impressive set of new features and fixes (i.e. things that worked in Postgres, but not with CitusDB).

In particular, the added ability to run `CREATE INDEX CONCURRENTLY` [1] for distributed tables is an important addition. I've run a pretty big Postgres database before, and this feature is absolutely _critical_ for bringing new indexes online for large tables without affecting users or other operations (without it, `CREATE INDEX` needs a lock that blocks other modifications in the table).

Its reverse, `DROP INDEX CONCURRENTLY` is a relatively newer addition to Postgres and also pretty key. While running on pre-9.2 (when it was added), we had to stop dropping indexes from large tables because the operation would block long enough that we'd start timing out user requests while it was running.

[1] https://www.postgresql.org/docs/current/static/sql-createind...

brandur··on A comparison of advanced, modern cloud databases
That's largely accurate, but the core point that I try to convey is that Mongo's key sales pitch is that you get sharding and scalability, but at the cost of features like ACID transactions, foreign keys, consistency checks, etc. Today, we have a great number of options that don't have to make these pyrrhic trade offs, and are just as scalable as Mongo.

If you want something that's portable, pretty scalable, and fast, go with Postgres. If you need something that's really scalable, there are plenty of other good databases on that list.

brandur··on A comparison of advanced, modern cloud databases
Sorry, there are many cool databases out there but I trimmed the list to the ones that I know a little about, and find most pragmatic/interesting. I'll willfully admit that the selection methodology is imperfect and somewhat skewed.
brandur··on Rclone banned from Amazon Drive for having the encrypted secrets in code
The nice thing about Rclone is that it already supports Google Cloud Drive (and a host of other providers) so the technology isn't the problem.

I'm lamenting Amazon Cloud Drive in particular because it was the best deal. $60 a year for unlimited storage and with no caveats (or so it seemed before last week).

brandur··on Rclone banned from Amazon Drive for having the encrypted secrets in code
Yeah, this is a hard one. There are users on /r/DataHoarder/ that claim to have uploaded literally 100s of (encrypted) TBs to Cloud Drive, which is plainly unsustainable and abusive.

On the other hand, they've also killed the product for a lot of more legitimate users as well. The Amazon web interface and apps for Cloud Drive are obnoxiously terrible, and Rclone really is just a better way to use it. I've been using it to sync 10s of GBs of photos between all my different computers, but with Rclone unavailable, I'll have to fall back to Google Drive, S3, or some other option (the unlimitedness of Cloud Drive was good peace of mind).

I'll be keeping an eye on it over the next few weeks to see whether shipping a binary with OAuth secrets was actually the reason for the ban, or just a pretext for getting the Rclone users off the service (personally, I suspect the latter).

brandur··on Cloud Spanner is now production-ready
I don't think there's any question at this point that Spanner is really cool. The vast majority of cloud databases out there (even brand-new ones like Azure's Cosmos) are still implicitly trying to convince you that not having ACID transactions is something that won't matter very much, and that scale is by far more important, which isn't true. Google hasn't taken that approach with Spanner, and it's a breath of fresh air.

I'd throw one downside out there though: lock in. While queries use standard SQL syntax [1], all write operations are performed via a very non-standard GRPC API [2]. I think the team certainly considered this and weighed the trade offs, but it does mean that after you're on Spanner, you're on Spanner forever.

[1] https://cloud.google.com/spanner/docs/query-syntax

[2] https://cloud.google.com/spanner/docs/reference/rpc/

brandur··on Two years of Rust
Oh totally agreed that C++'s compilation times are (quite infamously) a mess. I think that my parent was asserting that Rust's compile times are "usually ... far worse" (the "it" in the quote above is a reference to Rust).

For all I know, that might be true, but it's one of those "citation needed" type things.

brandur··on Two years of Rust
> I don't understand how (1) isn't a positive in your eyes.

I like testing as much as the next person and consider it very important, but your tests should be testing business logic rather than whether your syntax is correct. The problem with dynamic languages is that while you're certainly doing the former, you're also doing way too much of the latter. Until you hit runtime, you have no idea whether you misreferenced a variable or invoked a method that doesn't exist, so you end up writing an exaggerated number of tests that are repetitive, slow things down, and end up requiring considerable maintenance.

> (2) is true for pretty much every large statically typed codebase I've worked on.

Yes, incremental deployment is always a good idea, but it's a matter of degree.

Take for example a case where I need to rename a method that's widespread throughout the codebase. In a static language, I wouldn't give this a second thought. If there's a problem my compiler will catch it, and that's the end of the story.

In a dynamic one, this is a dangerous operation: the old method name may still be getting invoked dynamically in a non-obvious way, or another branch may have been merged _after_ I branched but _before_ I deployed that still has an invocation of the old name. Hopefully you have tests on these paths that will reveal the problem, but you might not, and to hedge against that possibility, you have to roll the change out to production carefully and slowly (because even there, it might be some time before some unwitting user inadvertently triggers the bad flow).

brandur··on Two years of Rust
Yes, I can't prove it. There's no quantitative way of doing so.

I've worked with very big duck typed codebases for quite a few years now (and largely statically typed in C# before that) and the above is my opinion. Duck typing is convenient early on, but it makes understanding code (especially where it gets complicated or you didn't write it) quite difficult, and any kind of refactoring downright scary. After a point you (1) start getting hugely defensive with tests because without close to 100% coverage you just can't know if anything works, and (2) stop making big changes and instead accept that small incremental deployments towards a greater end is the only safe way towards making progress.

I suspect that how much you agree with this statement is strongly correlated to the size of your codebase. I'd be surprised to meet people with codebases on the order of 100k lines or greater that don't largely share this sentiment.

brandur··on Two years of Rust
+1. Also, Go's goroutines and channels.
brandur··on Two years of Rust
I was partly relying on the context offered by the article and my parent comment to imply that sure, Rust's compiler isn't the fastest in class, but the team has identified speed as a major outstanding problem and is working very actively to address it.

Compilers are pretty hard. Languages like C and Go are able to short circuit the problem by having a simplistic type system, but the Rust team's main option here is hard work, and so far they seem to be more than willing to engage in it.

> At best it can beat C++ compilers - C++ being a language whose build times people love to bemoan - but usually it does far worse.

Citation needed on that one. How can you even make that kind of comparison fairly?

brandur··on Two years of Rust
> It's beginning to get tiresome to continually hear the Rust community go on and on about how amazing Rust is and say, with a straight face, that eventually there will be no reason to write anything in not-Rust. Are you serious? The hubris is off the charts.

So a few considerations here: (1) I really have no connection with the Rust community aside from curiosity, so it's quite dishonest to project my opinion onto all of them, and (2) this is very much my personal opinion.

---

I'd still defend the position though. Every language has merits, but especially for a lot of the older ones, there are so many accumulated problems that it's worth considering newer languages just because they're learned so much for the mistakes of their predecessors. For example, I've been doing Ruby for quite a few years now:

* Having so few constraints on implementation (e.g. duck typing) was an interesting concept, but time has proven it to be a nightmare maintainability. It buys you a little early productivity, but any honest person with a huge Ruby codebase can tell you that it's a liability.

* The only way to get truly good performance is to write a C extension. The language's whole implementation and performance-sensitive libraries are all C. Contrast this to modern languages where it's an embarrassment if your compiler is _not_ written in the language itself (Rust, Go, Swift, etc.).

* Core build infrastructure (Bundler) and environment management (rbenv) is maintained separately from the language. It works fine, but the reason it's not more core is not because it's better that way, but because the language's original designers didn't realize they'd be necessary, so they had to be developed separately. This has the effect of making the whole toolchain complex and hard for beginners to understand because none of it is integrated.

* The interpreter starts out faster than a compiler, but it breaks down fast. Codebases in the 100,000s of lines or more will take on the order of 10-100 seconds to start up, and the only way to get back to a fast edit-compile-debug loop is through tricks like Zeus. After you resort to that, unreliable runs and weird loading problems become a part of common life.

These aren't small problems. Also, I'm picking on Ruby here, but you could drill into a lot of existing languages and find flaws that are roughly on this level (JS/Python/C++/Erlang are easy, but even fan favorites like Haskell and Scala have pretty serious ones). Newer languages have their problems too, but rarely anything on this sort of existential scale.

We should stop pretending that all languages are equal with their own share of upsides and downsides. Given decades of language building, it would be disappointing if lessons hadn't been learned. Luckily this isn't the case.

In terms of what we write new projects in given a few years, there are other good contenders, but like I said above, I think that Rust has nailed a performance/safety/productivity/ecosystem compromise that's quite a bit above and beyond most of anything else.

← PreviousPage 5 of 11Next →