What do you mean by crappy? I've always found it very lovely and welcoming (though a touch small). The Julia community is also (in my experience) skewed towards scientific computing rather than software engineers which can definitely have an impact on things like "codebase quality" even in big important libraries. That's not a dig or insult – there are different priorities (privileging exploration, innovation, new ideas, and code that only needs to work until the paper you're writing is done rather than long term maintainablity is not a fundamentally wrong tradeoff to make).
Stefan Karpinski (one of the core Julia contributors) gave a talk (in 2016, so rather dated as far as the Julia syntax and whatnot go) about how Julia is secretly more lisp-y than even lisp & Scheme. The core of this argument is that most language specifications dedicate many pages to defining how arithmetic works, whereas Julia is actually just able to define that in Julia code as part of the stdlib (the implementation just calls out to LLVM intrinsics, but nonetheless, super neat!). `Int64` is actually defined in a Julia file.
I don't have any real issues with Go. Setting up GoLand requires manually choosing the Go installation to use (at `~/.asdf/installs/golang/1.19`) and manually changing it when I upgrade the project, but since the version of tools per project doesn't change that often, it's not bad.
The images shown at the top are (probably) designed to show off the full "dynamic range" of the color palette, but reading those code snippets is a bit overwhelming (and I suspect it's just because you've crammed so many things into a very small space). I think it might be easier to get a visual "grok" of the color scheme with a longer snippet that is more representative of real code.
Seconding this. It’s easy to be overwhelmed by the seeming combinatorial complexity of things. Just start a little personal wiki (eg, arrow syntax, structural typing, etc) and it’ll help you decompose things into more easily understandable pieces (it’s easier to multiply 7x5x21x22 than to factor 16170, if that makes sense).
Other than rm -rf / (which can happen if you manage to hit enter rather than another key) this feels not terribly useful. Who has accidentally kubectl delete ns prod? Anecdotally, the accidental enter seems like a much more likely scenario (I once ruined a server by chmod -r a+r / ing — that feels like a better use case for accident protection).
> [ Note: this is where I lost interest and stopped writing. ]
Kudos for actually bothering to publish the damn thing. Many people (myself likely included) would have spent hours agonizing over minute unimportant details and ultimately never actually get it out the door.
Admittedly I haven't played around with it too much, but I recently attended a keynote by the love Felienne Hermans that was all about her Hedy (https://www.hedycode.com/) "gradual" programming language. There are essentially progressive levels of the language that require more syntax rules (so in the lowest level `print hello, world!` just works™ and in the highest level, it's a syntactically valid subset of python, so you're expected to write `print("hello, world!")` -- and other constructs like functions and conditionals are introduced along the way).
As a shameless self plug, I've spent the past few years working on Pathbird (https://pathbird.com/) which doesn't use visual programming (it uses Julia/Python/R) but is really designed to let instructors create progressive lessons (a lot of use has been in non-CS courses, so imagine a stats professor using inline R code to visualize the central limit theorem). Happy to chat about it (travis@pathbird.com) if anyone is curious or just wants to shoot the shit.
Worth noting that some of these can be detected statically -- and some are detected by go vet (e.g., passing a sync.Mutex by value). I don't think it detects the wg.Add bug, but that seems relatively straightforward(†) to add a check for.
This is also what Yugabyte (OSS) does, at least according to my general understanding. It also supports the Cassandra API (though not to access the same data).
As a Seattleite who uses a bicycle as the primary means of transportation (but not a bike enthusiast or “bike person”): these are nice (experienced them a bit in Ann Arbor) but the only way to truly make biking safe is going to be to remove cars from the equation in 90%+ of circumstances. No bike gutters (a derogatory word for bike lanes that are only protected by paint), dedicated bike infrastructure.
At some point, you can't gracefully handle bugs in other peoples code. If a function you call causes a SEGFAULT, in the vast majority of software, you're not expected to handle that. That's an invariant error, and you probably want some way to detect that it happened so you can fix it, but it's not reasonable to ask every caller of every function to handle that (in the same way we don't consider "the earth blew up" to be a reasonable thing to protect against, even though it its technically possible). There's simply not enough time and money to protect against every possible edge case in most software (NASA projects aside).
The argument here is that network issues are exceedingly common in microservice environments and so aren't actually an edge failure case, so you actually have to worry about them way more than you would worry about a function in a different module causing a SEGFAULT.
There are products that do that! Hasura comes to mind.
But APIs can have different use cases. It’s usually considered bad to directly expose your table schema over GraphQL because it locks you in and makes it hard to change your data model over time. And not all API access is “get this data” and “set this data” — it can be difficult to express complex logic in just a database. And of course, some GraphQL APIs aren’t backed by a database - they’re backed by other services (a la the “backend for frontend” pattern).
I’m very pro choosing the simplest solution that works — but sometimes, the simplest solution does bring some complexity in exchange for other trade offs (like flexibility).
I’ve found it easiest to implement in Node due to the explicit event loop structure. You use data loaders, which is a super generic term that means “batch all requests for this resource into the next event loop tick.”
So when a query requests a list of users, and then every users friends, that becomes two queries: one to load all the users, and one to load all the friends for all those users. The net effect is that your number of queries is O(query depth) rather than O(objects requested).
Admittedly this does tend to work best with more K-V oriented data that truly relational data, and might be hard to retrofit onto a brownfield project, but i’ve never found it all that hard to do.
Facebook has a terrible track record when it comes to open-sourcing their internal tools. See: Phabricator, HHVM, Flow, Jest, ...
Even React, which is their most popular library, is not actually "open source." They're very transparent about the fact that their priorities are Facebook's needs -- even if they do take community input.
None of this is per-se bad, but you should definitely treat an open-source project out of Facebook with skepticism when it comes to adopting it for your own use cases (possibly making sure you're not too locked in when an incompatible v2 comes out with virtually no warning after FB's internal implementation drifts).
I think out loud you'd be more likely to hear "here're your donuts" rather than "here's your donuts"), but when written, here're looks way worse. Language (written, spoken, and otherwise) is interesting and resistant to fitting into nice, neat, tidy boxes.
i’m also not a db engineer, but i think this is true-ish. however building and maintaining those index tables is hard and probably prone to issues if you can’t update multiple as part of the same transaction.
the other major thing you’d miss is smarter joins. the distributed databases do a lot of work to be able to push down predicates as far down as possible to the physical nodes storing the data.
Interestingly, I suspect Facebook employs the largest auto-loaded codebase in the world and I suspect this is made easier by the fact that everything is controlled under one roof. There is some namespacing (à la PHP namespaces) for standard library stuff, but most naming just takes the form <TeamName><NormalClassName> to avoid any conflicts.
I learned Dvorak because I knew I would never work out the bad habits I had with QWERTY. Dvorak is a HORRIBLE layout for mobile, but I used it for about a month while learning Dvorak and it really helped. It’s horrible since you often type in mobile with one hand which means your fingers get tired quickly from moving between the sides of the keyboard. I’ve never really had issues going back to QWERTY keyboards (no more so than usual slight frustrations when moving between slightly different keyboards).
In my experience this isn’t idiomatic Go and would definitely turn heads in a code review. But in such a small function, it’s fine to just not worry about the lifetime of your variables (and in bigger functions you can often decompose into smaller functions).
This is definitely not the case. This publication has multiple posts about the supply chain and port affairs. Software/tech people sometimes forget that we live in a very specific world with very limited scope, and sometimes forget to take our blinders off when interacting with the “real” world.
Yep, and beyond that, there's still a need to remove cars from the world, both to fight climate change and to make cities livable again (see any video from the "Not Just Bikes" YouTube channel for support for this argument). Moving everything to autonomous cars (even, yes, electric autonomous cars) will not solve those issues. Smart urban planning and structural reform are the only things that really stand a chance there.
I think here “rewrite” means completely changing the internal structure of the code (while preserving the functionality) whereas “port” means copy the structure of the internal code with as little modification as possible. And it’s hard to do the latter in Rust since Rust is not garbage collected.
To this point, many teams are already using subsets of TypeScript to improve compilation times. Often times it’s things like always declaring return types on functions to avoid the compiler having to infer it (especially between module boundaries). Calling this a “subset of typescript” might be strong wording, but it does suggest there is some desire in that general area.
My impression of the article is just that the author is a fan of green threads (goroutines). Green threads don’t really make sense without an integration into some kind of IO runtime, so calling out how Go does do this seems moot. Other languages with green threads also with this way (Julia comes to mind).
This article undermines itself the second it moves from “here’s the problem” to “here’s the solution:”
> Be mindful of not leaving your codebase in a broken state during this step
You’re still relying on very fallible human intervention here. Even worse, often times when grouping commits post-facto you’ve forgotten some of the context of what depends on what.
Ostensibly the approach presented could be better than other strategies in this regard, but that’s now how the article presents itself and it loses credibility for that.