It's been a larger sequence of events until I got hired, but it all started by having shared a little side project[1] here that hit the front page in 2016.

Back then, Zach[2] from Timber.io reached out to me since they had just recently launched a startup in the logging space. We had a good exchange, but didn't get to work together. (I was burned out from my job and wanted to go back to university to study computer science, and felt that accepting "yet another job" wouldn't give me the perspective and foundational knowledge I was looking for. So I proposed a ridiculous rate that they understandably declined.)

However, we kept in touch over the years and I had good memories from our conversations.

During my studies, I fell in love with Rust. When I finished my bachelor's degree in 2020, I was looking for jobs in Rust that were specifically not in the blockchain/crypto currency industry (disqualifying at least 90% of the postings I had seen). Then Vector[3] caught my eye – a project by Timber.io. So I reached out to Zach again, and even though I had been fairly inexperienced in Rust, they took a shot on me. Eventually, Timber.io got bought by Datadog in 2021, and I sticked around until the end of 2022. After that, I was fully focused on finishing my master's degree.

To close the circle, I ended up founding a new company with Zach at the beginning of this year. We're still in stealth, but working on open source real-time video communication. If you're interested in tackling hard challenges in infrastructure/networking/native UI with Rust, please feel free to reach out – we have some open positions and I would love to reach for the same community that has once so openly accepted me.

[1] https://news.ycombinator.com/item?id=12830763

[2] https://zach.sh

[3] https://vector.dev

There's still a couple of universities that offer a "Diplomstudium", e.g. TU Dresden: https://tu-dresden.de/ing/studium/studienangebot.

> and studying computer science doesn't grant you the title of "Ingenieur" anyway

That's not correct. E.g., consider the relevant section in the Bavarian engineering law[1] (using Google Translate):

> The job title engineer alone or in a word combination may use,

> (1) Anyone who has successfully completed an undergraduate degree at a state or state-recognized German university

> a) in a technical-scientific subject,

> b) which has a standard period of study of at least six full-time semesters and with which at least 180 points can be acquired using the ECTS system and

> c) in which the areas of mathematics, computer science, natural sciences and technology predominate; this requirement does not apply to people who have completed an undergraduate degree in industrial engineering and only use the professional title in the word combination industrial engineer

Further, my diploma for a Bachelor's in Computer Science from TUM contains the passage:

> The graduate is entitled to employ the designation Engineer alone or as part of a compound word.

[1] https://www.gesetze-bayern.de/Content/Document/BayIngG2016-2

Hm, that's an interesting choice. I also wonder why they didn't use an encoding that has an alphabet with 2^n characters (that way you can directly map 1 charater to n bits when decoding).

Coincidentally, I've just finished some work on a project[1] that is in the same space (identifiers for images).

For the reasons you pointed out, I found Douglas Crockford's base32[2] encoding to be a good fit.

[1] https://github.com/pablosichert/ciid

[2] https://www.crockford.com/base32.html

That choice is explained in the README: https://github.com/woltapp/blurhash

(83 is about as many safe characters as you can reasonably find, and it allows some nice ways of packing values together.)

Could you explain what "AC components" refers to? I couldn't figure that out just by reading your README.

I wonder how the efficiency compares to just encoding on the bit level.

It is a term often used for DCT-transformed data. DCT, in this case, breaks the image down into basically an average colour of the whole image, referred to as the DC component, and a bunch of waves that make up the detail of the image, referred to as AC components.

https://github.com/woltapp/blurhash/blob/master/Algorithm.md

> Could you explain what "AC components" refers to?

All but the first component of the Fourier transform. (The first component is the average of the data.) The term comes from electrical engineering, but Fourier transform has lots of applications also outside of electrical engineering.

Hey there, author here.

I have an image library of around ~15,000 RAW photo images, which I wanted to organize. After having tried several approaches over the years (organizing them in folders by topic, by year, or some mix of the two...) I gave up and went to build a solution that scales better.

ciid is a CLI utility, which you can use to rename image files, so that you can fearlessly merge folders without having to worry about duplicate file names.

The derived identifiers are structured in such a way that if you sort them alphabetically, the images will also be sorted chronologically. Additionally, the identifier can later be used to verify the integrity of the image.

If you have any questions, I'd be happy to answer.

Great idea! I didn't know I needed this :)

Haha, great! I thought there certainly must be other people in a similar situation like me and find this useful.

If you hit any problems or have a feature request for your use case, just let me know in the issues.

I've been working on a very similar framework[1], but wasn't satisfied with the ergonomics enough to release it.

My plans were to extend the Swift compiler with JSX-like syntax[2] that makes use of the declarative framework. Of course that's still possible, especially now with a canonical "Apple" way of building declarative interfaces in Swift.

I'm a bit sad that with the announcement of SwiftUI my implementation will not stand a chance anymore, but I definitely learned a lot along the way how declarative rendering and reconcilation works in detail.

Bottom line - this is very great news for native app development, declarative UI makes it vastly more easy to reason about code.

[1] https://github.com/PabloSichert/Sx/blob/master/Example/Incre...

[2] https://facebook.github.io/jsx/

Currently starting to build a native macOS/iOS/watchOS productivity app, therefore picking up Swift.

I'm coming from web development - and feel a bit stuck on how to layout things with Xcode / Swift. I'm not convinced by the graphical way to build interfaces provided by Interface Builder / Storyboards, as they feel quite limited in terms of precise control, dynamic layout, no duplication and use with VCS.

Optimally there would be something like React to build interfaces declaratively.

Does anyone have some insight into this topic?

(Also: why are variable declarations so implicit in Swift? When importing a package all its exported variables are avaliable within the file, making code really hard to read in my opinion.)

You can build your UI programmatically and not touch storyboards/xibs. A lot of people do this and I am slowly moving away from IB myself. This library has been recommended for doing autolayout:

https://github.com/nakiostudio/EasyPeasy

I'd be interested in such a solution, also in regard to the input from another commenter to make this work with nginx.

If you have a concrete idea and eventually a project on GitHub, feel free to contact me! Would like to contribute

Sorry, I couldn't quite follow - could you break it down in simple sentences what the connection between those links you provided and the visualization is?

The coloring depending on response time happens in intervals, that much I can say.

I am not saying anything very deep. We can try to count all the different ways 5 (or 100) people can have sessions on a website

  #1 |--------------------|
  #2        |---------------|      |---------|
  #3   |------------|          |---|
  #4      |----|             |------|      |--|
  #5   |---------------------|

Each of these channels have overlapping event. Some sessions happen strictly before the other. Sometimes, one logs on before the other one logs of. Etc. The more channels we have the more complex behavior. That is all the paper is saying.

Sorry about that.

Thanks for making that example!

Assuming I am looking at your sketch with the x-axis being time, I just want to note that specific to this library there won't be two events (request start, end or log) at the same time. (The "concurrency" here comes from coroutines, not parallel threads)

My mistake. I only see a few outcomes then. #1 happens then #2

  #1 |------|
  #2             |--------|

and #2 happens before #1

  #1                  |-------|
  #2   |---------|

or #1 starts then #2 starts:

  #1   |-------------|
  #2           |------------|

or #1 starts before #2 and finishes before #2

  #1  |---------------------|
  #2       |----------|

For two channels are are 8 possibilities in all. https://oeis.org/A079144

Any plans on releasing a version that is not tied to the apple ecosystem? ("super/windows" vs "option", "command" vs "alt") Why are those not configurable, as well?

Are "fn" and "control" swappable?

The peripheral keys which were static in the old design was because we had to use an existing display. Making a custom E Ink display needs to be in at least 300k minimum order quantity and a $500k NRE so we had to wait until we had a mass production order; the current design has a new display which means all the keys are remappable.

It wasn't lazy design, just a compromise we had to make until we had the capital.