HNHacker News
TopNewBestAskShowJobs

YorickPeterse

2,784 karma · joined March 29, 2011

Author of the Inko programming language, formerly a staff developer at GitLab.

Website: https://yorickpeterse.com

submissionscomments
YorickPeterse··on Gitlab's Guide to All-Remote
We generally don't as far as I know. Most communication happens async anyway due to the timezone differences. When I do need to diagram things I tend to create Mermaid graphs in issue comments, but beyond that I never really felt it was necessary.
YorickPeterse··on Firefox 75 on Wayland now to have full WebGL, working VA-API acceleration
Also worth mentioning: Wayland has no support for color management at the moment. Work has been ongoing on this for about a year now, but I think it hasn't really solidified yet into something you can use.
YorickPeterse··on RuboCop 0.80: Ruby static code analyzer and code formatter

    > 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.
YorickPeterse··on Reasons not to become famous
> Hypothesis: On twitter, when your follower count exceeds the number you're following, you become a little nutty.

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.

YorickPeterse··on Gitlab proclaim diversity, but seems to have a real issue keeping women on staff
Thanks. I realise all of this can be very difficult. If it's of any use, feel free to chat me up on Slack about this. I'm not sure to what extend I can help, or if you'd even be comfortable with it (since Slack has no anonymous communication mode), but just know the offer is there :)
YorickPeterse··on Gitlab proclaim diversity, but seems to have a real issue keeping women on staff
> At this point the legitimacy of my account has even been called into question > internally. It certainly seems like they are interested in discrediting > everyone they possibly can. We wouldn't want anyone to actually be moved to > action or anything.

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".
YorickPeterse··on Mir: A lightweight JIT compiler project
I believe Rubinius _is_ being maintained (again), it's just going in a direction very different from Ruby.
YorickPeterse··on Mozilla lays off 70
If I remember correctly he didn't get fired for just not supporting gay marriage, he got fired for donating to some bill that was trying to prohibit gay marriage. That's quite the difference.
YorickPeterse··on Show HN: Beef, a new performance-oriented programming language
When making the Inko website I saw a bunch of other language websites (e.g. D's website) use this approach, so I copied the idea. I'm glad it turned out useful :)
YorickPeterse··on Structure and Interpretation of Computer Programs – JavaScript Adaptation
Yes, it's such a great language that `{} + []` is a valid program.
YorickPeterse··on Garbage Collection
> increment of a pointer (and that is atomic, so no thread locking needed).

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).

YorickPeterse··on Garbage Collection
ARC is just reference counting, as there's nothing in reference counting that requires a runtime to do this for you (that is, just because the compiler inserts increments/decrements doesn't make it an entirely different thing).

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.

YorickPeterse··on Gitlab was down
I would not call myself an operations expert by any means, but I have done quite a bit of infrastructure work in the past; both with bare metal setups and cloud based solutions.

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.

YorickPeterse··on Gitlab was down
It took about 24 hours to recover, not "a few days".
YorickPeterse··on Ask HN: Do you write tests before the implementation?
I usually start with a REPL, then play around with that for a while. For languages without a REPL I usually just create a one time file in the project and play around with that.

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.

YorickPeterse··on Gitlab's Director of Risk and Global Compliance Resigns
> We could, but we are all literally terrified for our jobs and of retaliation.

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.

YorickPeterse··on Update on free software and telemetry
Which has been moved to https://gitlab.com/gitlab-org/gitlab/issues/34833, since it was using the wrong issue tracker before.
YorickPeterse··on Conventional Commits: A specification for structured commit messages
I agree that full sentences (e.g. like Email subjects or blog post titles) are better. Tagging commits with feature/bug/etc is not particularly useful, as more often than not the line between feature, bug, etc is blurry. At times it can also be unclear what tag to use, leading to arbitrary choices. For example: is a performance improvement a feature, or a bug fix? The tags also add no value when reading commit messages.

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.

YorickPeterse··on Gitlab More Than Doubles Valuation to $2.75B Ahead of Planned 2020 IPO
As far as I know we don't have any recurring reports on data like this, though I think we may have mentioned it in the odd blog post in the past.
YorickPeterse··on Inko 0.5.0 released, featuring the first steps towards a self-hosting compiler
I suspect there might be a better way of phrasing this, though I am not quite sure how.

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.

YorickPeterse··on Maturity
> Gitlab isn't big company, 100 devs or so

384 engineers, out of a total of 873 employees. I'd say that's a pretty reasonable size.

YorickPeterse··on Building Interactive SSH Applications
No it's not, at least not always. Depending on the query, data, and/or indexes, PostgreSQL will optimise this into a WHERE EXISTS, which in turn is more or less the same as an INNER JOIN. Also, I think you might be commenting on the wrong post.
YorickPeterse··on Why we're ending support for MySQL

    > 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

YorickPeterse··on Inko (a gradually-typed object-oriented programming language) 0.4.0 released
Due to the length limit of HN titles, here is a short summary of what Inko is about:

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/

YorickPeterse··on GitLab Strategy
Salaries at GitLab were increased (at least for engineers) towards the end of 2018. This meant that at least my salary went from so-so to something I am actually really happy about (this was combined with some other adjustments, such as my experience level), and something that is hard to beat here in The Netherlands.

In other words, the opinion will vary from person to person.

YorickPeterse··on GitHub Package Registry
I think you mean the other way around, as GitLab CI has been around for years.
YorickPeterse··on The Lost Futures of Mark Fisher
I think a big difference between Christianity and Islam is that in the west Christianity has been around (or at least more dominant) much longer. I think this has two effects:

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.

YorickPeterse··on Building Fast Interpreters in Rust
Inko (https://inko-lang.org/) uses this approach for its bytecode interpreter. I can't speak about how well it performs compared to an AST interpreter since I never wrote one for Inko, but generally bytecode interpreters should be faster. I also think bytecode interpreters would be easier to optimise, as you're no longer directly tied to the AST of the input language.

If you're curious, you can find Inko's interpreter loop here: https://gitlab.com/inko-lang/inko/blob/master/vm/src/vm/mach...

YorickPeterse··on Pagedraw is shutting down and going open source
I think there are also two other problems with WYSIWYG editors that haven't really been solved:

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).

YorickPeterse··on Why I Write CSS in JavaScript
Clearly when somebody has a bad experience, they are just doing it wrong.

Or perhaps there's something to it, and the idea is not as good as one might claim it to be.

← PreviousPage 8 of 14Next →