2,784 karma · joined March 29, 2011
Website: https://yorickpeterse.com
> How much time do developers spend on side by side buffers?
In my case: all the time. On my desktop (which has a large display) I often tend to have 3-4 vertical buffers open. Being able to fit all my code in those buffers is a godsend.I follow 8 people, and have 1029 followers. Following this hypothesis, I would be batshit crazy. I don't think this is a very good hypothesis.
I am the one who questioned the account, so I think I can comment on the matter. Specifically I said the following in Slack (in reply to some discussion about the things going on on Hacker News):
> The "culture of fear" thing was something mentioned a few months back on
> HN as well, though it remains to be seen if the account in question is
> genuine
I'm not sure how you can interpret that as "they are interested in discrediting
everyone they possibly can". In fact, I think it's disrespectful to throw
somebody who simply questioned an account's legitimacy on the same pile as
those who "are interested in discrediting everyone they possibly can".Nitpick (and mostly for others reading): incrementing the address of a pointer if done locally (as in, using a local variable of sorts) may be atomic, but storing the updated pointer somewhere may not. If a bump allocator wants to support concurrent allocations, it should make sure to use the right atomic operations (typically this just a compare-and-swap of the old pointer with the locally incremented one).
The reason reference counting is not more common is because of its performance. Naive reference counting works in some cases (e.g. when the counts are not modified often), but doesn't work too well for most programming languages, as the reference counts will be modified frequently.
Deferred and coalesced reference counting are two techniques of improving performance, but they come at a cost: they are quite complex to implement, and require additional memory to keep track of what/when to increment/decrement. You will also end up facing similar nondeterministic behaviour and pauses, as an optimised RC collector may still need to pause the program to scan for cycles. You can handle cycles by supporting weak and strong references, but this puts the burden on the developer, and it's not always clear if cycles may appear when writing code.
Combining this with a good allocator you can achieve performance that is on par with a tracing collector (http://users.cecs.anu.edu.au/~steveb/pubs/papers/rcix-oopsla...), but it's not easy. If you are going down the path of implementing a complex collector, I think you're better off focusing on a real-time or concurrent collector.
With that said, the old database specialist position was about 80% engineering, 20% infrastructure, with the infrastructure work being done in cooperation with the production engineers.
I left the database team a good year ago and quite a lot has changed since then. I think these days we have a handful of people focusing on the database side of things.
Once I am a bit more comfortable with the code and have a better understanding of what I need, I will start writing some tests. I usually don't write too many early on, this way I don't have to go back halfway through development and change all my tests. Only when I'm confident enough with the code do I start writing extensive tests and try to cover all cases.
This is the first time I'm hearing this, and the people I work with certainly don't feel like htis. I suggest not saying things like "we all", when that clearly is not true.
Setting that aside, the conventional commit "standard" (https://xkcd.com/927/) doesn't focus on what I think is the most important aspect of a commit: a good commit subject and message. In fact, prefixing the subject line with certain tags limits the amount of characters you have for writing the message; assuming you want to stick with the usual 50 character limit.
The example you are showing here relies on dynamic typing. When you use dynamic typing, pretty much all bets are off. When the website mentions error handling, it talks specifically about using exceptions. Take for example the following Ruby code:
def foo
# lots of code here
raise TypeError, 'Foo must be of type X'
end
When you call this method, you have no idea what it might raise. If you're lucky somebody might have documented this, or maybe there is a test that clearly shows this. This is what we mean with unexpected errors: an error popping up (intentionally or not) that you were not aware of.Inko tries to tackle this by requiring you to tag methods with the error type, and limits you to only a single error type per method. Combined with having to use `try` or `try!` for such methods, this makes it immediately clear that (and what) a method might throw. If a method tries to throw without the tag, it will not compile.
384 engineers, out of a total of 873 employees. I'd say that's a pretty reasonable size.
> All they had to do was implement a nested set pattern for their groups
The nested set pattern was considered at the time we added support for nested
groups, or improved it with CTEs (not sure which one of the two it was). The biggest drawback of nested sets is that adding sub groups can now
become expensive. The storage needs are also far from ideal.Using PostgreSQL CTEs allowed us to work around all of this, at the cost of not supporting MySQL. This seems like a fairly reasonable trade-off, but I might be biased as I implemented it [1].
> A hack? Their DB creation schema specified a TEXT column when it should
> have been a LONGTEXT column. Using LONGTEXT is not a hack, it's a choice
> when your data is more than 65535 characters, and they made the wrong
> choice out of ignorance.
It's not ignorance, it's MySQL coming up with bizarre limits for the "TEXT"
type. In MySQL, the limit for TEXT is 64 KB. In PostgreSQL, IIRC it is 1 GB.
Looking back there may have been better decisions, but it's always easy to judge
in hindsight.More importantly, moving away from MySQL allows us to stop worrying about this at all.
> Alternatively, since this is filepaths and filenames, they could have used
> a nested set pattern again and gotten 255 characters for each component of
> the path and a lot more feature options for their search system!
At the cost of requiring more storage space, and writes taking (potentially)
much longer. You may want to mention that, instead of acting as if nested sets
are a silver bullet. > This is true, but is it really a show stopper?
Yes. > Wrong schema specifications and not knowing to implement nested set
> patterns is a sign that they don't have a knowledgeable DBA on staff.
You may want to do some more research before going down the path of suggesting
GitLab employees lack knowledge. For the last two years or so we've had various
engineers with excellent database knowledge working on GitLab, myself included
(though I don't consider myself a PostgreSQL expert).Some of the weirder decisions were made before the right people were hired, and often these decisions are difficult to improve upon. Sometimes removing support for something is a much more efficient way of spending your time. Removing MySQL support in GitLab is one such case.
[1]: https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/10885
Inko is an object-oriented, gradually-typed, safe programming language that lets you write concurrent programs, and is inspired by languages such as Smalltalk, Erlang, and Rust. For more information, please take a look at the website: https://inko-lang.org/
In other words, the opinion will vary from person to person.
1. People are more used to it, and likely less aware of the flaws it has (or might have, as this is in the eye of the beholder). This may lead to people to make claim X, Y, Z about Islam, forgetting that this may have applied in the past (or still does) to Christianity as well
2. It had more time to develop according to the "western ways" so to speak.
Of course this will vary per country, and the US is big enough that it probably even varies per state. The Netherlands for example doesn't really have anything close to for example the Westboro Baptist Church, at least not that I know of and is anywhere near as widely known.
If you're curious, you can find Inko's interpreter loop here: https://gitlab.com/inko-lang/inko/blob/master/vm/src/vm/mach...
1. They tend to produce output that is not ideal to work with using another program (e.g. your editor of choice).
2. When you make changes to the output, the WYSIWYG editor might not understand it. This very much depends on what is changed, how, etc, but it could be a problem.
Both essentially force you to use the same software, and I think that scares people away (rightfully so I'd say).
Or perhaps there's something to it, and the idea is not as good as one might claim it to be.