alco

Location: Lucca, Italy

Remote: Yes

Willing to relocate: No

Technologies: Elixir, Go, TypeScript, Postgres, SQLite, Docker, AWS, sync engine, containers, distributed systems

Resume: https://sholik.dev/resume/

Email: [email protected]

I build data infrastructure: sync engines, durable streams, and backend systems that must stay correct through load, restarts, and failure. I have expert-level, hands-on knowledge of Postgres logical replication and of the BEAM VM's concurrency and memory model. I'm looking for a remote senior software engineer role in distributed systems, replication, storage, AI agent infrastructure, or performance engineering. I'm deepest in Elixir/OTP and Postgres, productive in Go and TypeScript, and more interested in hard systems problems than any particular language.

From https://firebase.google.com/docs/data-connect/data-connect-e...:

> Firebase Data Connect provides you with a local emulator for end-to-end prototyping as well as continuous integration and continuous deployment (CI/CD) flows

Developers at Google have chosen PGLite for those qualities so that users of Firebase Data Connect had better CI/CD workflows. It wouldn't be fair to say this is an insignificant use case.

  Location: Kyiv, Ukraine
  Remote: Yes
  Willing to relocate: planning a move to UTC time zone within the EU
  Technologies: Elixir, Go, TypeScript, Python, AWS, GCP, Docker, Kubernetes, PostgreSQL, RabbitMQ
  Résumé/CV: https://www.dropbox.com/s/6njitiijrb0gs37/Oleksii%20Sholik%20Resume.pdf?dl=0
  Email: [email protected]

Hi, my name is Oleksii. Having worked as a backend engineer for the past almost 10 years, I'm an expert in Elixir/OTP and PostgreSQL, skilled in Go, AWS, and Kubernetes. Looking for new challenges in distributed computing, global data consistency, high scalability, and observability.

I actively contributed to the Elixir programming language between 2012 and 2016, developing UX improvements for IEx (colors, history, .iex.exs), implementing core functions in Enum, List, OptionParser, String, System modules.

Honestly, most of them were great. Probably the most captivating one was Ben Tyler's fun exercise in using Riak Core to build a stateful, distributed, fault-tolerant, real-time, impress your cat application.

Chris McCord's keynote was also really interesting, he explained how he implemented Phoenix Presence using a certain kind of CRDT.

And for some laughs I recommend watching Gary Rennie's funny story about achieving 2 million clients simultaneously connected to a single Phoenix server.

I agree. Setting up mirrors would probably be a better fit for this kind of content, but mirrors would be susceptible to the same dangers that the primary website may face: forced take-down by the hosting provider, domain blocking, etc.

The fundamental difference of content-addressed networks is their resiliency in the face a single authority trying to track down all of the sources that have copies of the content.

Even though IPFS is still in its infancy, one of its primary goals is to solve the problem of content suddenly disappearing from the Internet.

Have there been attempts at dispersing the whole collection of papers through torrents or IPFS? The goal here is not to have a central location with a pretty web page but to make the content freely accessibly everywhere by anyone. Distributing it over thousands of nodes would achieve that goal.

I tried to use the Chrome extension to read a Spanish website but it doesn't work unless I enable 3rd party cookies. That's quite rude. I cannot allow a single extension to compromise my browsing experience by letting anyone set 3rd party cookies.

Could you please add a field on the site where I could paste the URL of a webpage? That would work for me as a workaround to using the extension.

Elixir has first-class support for defining custom types and adding type annotations (specs) to functions. There's also a tool that makes it very easy to run dialyzer on your code: https://github.com/fishcakez/dialyze

JavaScript has functions. The list pretty much ends there. There are some libraries that provide "functional features" like functions over collections, persistent data structures, promises. The language itself and the environment it's running in (DOM or Node) do not have a lot going for them in terms of functional programming essentials.

Erlang/OTP is being developed continuously, primarily by a team at Ericsson. They ship one new major release roughly once per year, with a few minor releases in-between.

First question in the Q & A here sheds light on the authors motivation for creating Wren:

http://munificent.github.io/wren/qa.html#why-did-you-create-...

Just a small note: Go has also abandoned segmented stacks. They were a placeholder until Go got precise GC which enabled it to use contiguous stacks with pointer rewriting. Here's a good explanation of this – http://agis.io/2014/03/25/contiguous-stacks-in-go.html.

Open source community.

Instead of the animation speed setting it should have a slider (like, for instance, here http://debug.elm-lang.org/edit/Mario.elm). Otherwise, it's more like a nice animation than a learning tool.

Erlang knowledge is not a requirement to start learning Elixir. You will end up learning about Erlang programming model anyway because Elixir builds on top of it.

By "programming model" I mean things like immutability, concurrency, fault-tolerance, and the way you design systems with OTP.

Where is the promised "synchronous syntax"? The first example show an ordinary async call with a callback.

This list says little about Rails' productivity benefits without also stating how much is hidden behind it (in terms of queues, caches, async workers, etc.) to let those services handle their job.

I realize now it sounds as if Erlang got something wrong and Elixir got it right instead. That's not what I wanted to say.

Elixir semantics is very close to Erlang's, but it also has things beyond what Erlang can offer as easily: macros, protocols, comprehensions with any kind of enumerable as a generator.

Of course, the core facilities provided by the runtime system are left unchanged: concurrency primitives, functional semantics, distribution, error handling (Elixir has slightly different conventions, but the idea of "letting it crash" remains). And in OTP land there are quite a few additions that simply make OTP more "elixirish" (like getting a lazy stream of events from GenEvent).

I wasn't implying anything beyond the quoted phrase. My last remark was targeted at anyone reading the comment, I didn't mean to sound condescending towards you.

I don't share your belief that early libraries and frameworks have the potential to override Elixir's broad domain. In other words, even if there will be a widely popular library/framework for Elixir, it won't automatically negate its other strength or fitness for a wide range of uses.

During the recently held ElixirConf we've seen it used in a telecom company, also powering game servers, distributed robots, and hobby projects like an elevator controller and command-line applications. The community already has a diverse set of interests and many of us will be pushing the adoption in our respective areas of interest.

In any case, our best effort today would be to continue hacking and having fun with Elixir, and at the next year's conference we'll be able to see in which direction the trends go.

> We should avoid making Elixir a Ruby-on-Erlang when it has the potential to be so much more.

Elixir is fool-proof from turning it into a "Ruby on Erlang" simply because it embraces and improves on Erlang's programming model. Some libraries are ported over from Ruby. But there are also libraries ported from other languages and libraries that have been written for Elixir specifically.

Just a heads up: please don't make hasty generalisations based on a single project you've seen.

'wc -l' counts the number of lines. It also supports '-c' and '-b'.

To work with input split into columns, use awk. By default, it assumes the columns are separated with spaces. This can be customized with the '-F' option.

So your last example can be rewritten as

    awk -F, '{s+=$1} END{print s}' data.csv

A lot of the designs on that page would look better if they covered the logo.

The differences are more than just in syntax. Elixir is also a standard lib that many enjoy, out-of-the box tooling (even Erlang folks have praised mix, the project manager for Elixir), meta-programming.

For example, this code generates a bunch of functions using some compile-time code execution and a macro: https://github.com/alco/benchfella/blob/2513f85eff3886fdf1b3.... Doing the same in Erlang would involve using some 3rd party tool for code generation or doing the whole thing at runtime, in a more verbose way.

In short, achieving similar development productivity with Erlang would be quite a challenge.

I don't understand what you are asking here. The example at the beginning of the "Distribution" section shows how to get the value from the door in room1 while running on the node corresponding to room2.

The same way you can call 'Portal.Door.get({:orange, :"room2@COMPUTER-NAME"})' on the first node (the one corresponding to room1).

"Some concurrency" and Erlang-style concurrency are a thousand miles apart. Read this www.erlang.org/download/armstrong_thesis_2003.pdf. No matter which language you are using, this will help you expand your perspective on the subject of building reliable systems.

Saying it is bounded by O(n²) is too vague, because it's the same as being bounded by O(n³) and so on. A linear algorithm is also O(n²) and O(n³).

That is why I emphasized that the worst case in particular has its bound within a constant factor of n², hence Ɵ.

It is worth pointing out here that Quicksort has complexity of Ɵ(n²) in the worst case. Yet it has worked out as the best one in practice in many applications.

That's not one pixel. That's a line one pixel high and the whole tab bar wide.

You don't need ad-hoc polymorphism to implement polymorphic operators. Haskell does that with type classes that provide parametric polymorphism.

It strikes how every single one of these tools assume you have an empty contribution timeline to begin with.