DockYard Blog

Shameless plug; I recently wrote a blog post about suggestions on improving your audio for remote teamwork: https://dockyard.com/blog/2021/02/08/improve-your-audio-to-boost-remot… Although I do suggest the Shure MV7 mic, which I use, there are example of really cheap ways to immediately improve how you sound over conference calls. Another tip I talk about us using RNNoise, which does an excellent job at cutting out background noise while preserving your voice. It's built in to OBS if you ever want to try it.

You definitely should learn - it's a lovely domain for geeking out -- but you first need to acquaint yourself with the technical domain. I honestly don't see how an example would get you from 0 to nodes up and running with understanding. Here are two good starting points (since Bastion is the same type of platform): https://learnyousomeerlang.com/what-is-otp https://dockyard.com/blog/2018/07/18/all-for-reliability-reflections-o… That first link has what you want: examples. But note how many pieces are involved and that it is not a 5 minute read :) Top level, a project like this needs to communicate to the intended audiance -- here, people who are building F/T distributed actor systems -- what the project brings to the table, and imo they did a good job in that regard.

Alchemist Camp has good video tutorials https://alchemist.camp Also this blog post helped my understanding http://www.petecorey.com/blog/2019/05/20/minimum-viable-phoenix/ Phoenix LiveView [0] is really exciting to try out in Elixir. I'd recommend building an auto updating dashboard. I had a micro controller that had various sensors on it that I connected to over a serial port using circuits_uart[1]. I then read the sensor values and displayed them on a LiveView dashboard. Totally pointless but super fun :) [0]: https://dockyard.com/blog/2018/12/12/phoenix-liveview-interactive-real… [1]: https://github.com/elixir-circuits/circuits_uart Sidenote. If anyone has any Elixir freelancing work I can do send me an email. Email in my HN bio.

I don't know Go, but that probably depends on your goals. To quote myself from elsewhere: > Efficiency in the BEAM is mainly in service of its primary goal of fault-tolerance. If one process crashes unexpectedly, the others should continue. By the same logic, if one process is CPU-intensive or IO-blocked, the others should keep making progress smoothly. And if processes are good for isolating errors and performance issues, they should be cheap enough that we can run a lot of them at once. Those assumptions are baked into how the BEAM manages processes. If raw speed is your only goal, the BEAM probably isn't the best choice. If consistent speed and stability matter, it may be. More on this at https://dockyard.com/blog/2018/07/18/all-for-reliability-reflections-o…

Personally, I'm very interested in the possibility of Phoenix LiveView giving us the best of both worlds: https://dockyard.com/blog/2018/12/12/phoenix-liveview-interactive-real…

No, PWA add to homescreen is since 11.3 https://dockyard.com/blog/2017/09/27/encouraging-pwa-installation-on-i… They do even auto-delete the PWA-apps [Quote] If the user doesn’t use the app for a few weeks, iOS will free up the app’s files. The icon will still be there on the home screen, and when accessed the app will be downloaded again. Not very trustworthy for using a PWA on iOS it seems :)

Yes! Phoenix creator here. We need to give the blog some love, but in 2015 we had a big year. We released the "Programming Phoenix" book for pragprog and our big "Phoenix Presence" feature, a CRDT backed eventually consistent process group: https://dockyard.com/blog/2016/03/25/what-makes-phoenix-presence-speci… We also have been working on Phoenix 1.3 which I laid out in my ElixirConf keynote. Ask me anything!

I've used two techniques: 1) use a prefix (t-) for test selectors and do not attach any styles to them (put them on the elements you need to target directly so the tests do not have to know about the DOM structure) 2) use data- attributes for test selectors (again directly on the target elements so DOM changes won't break the tests) The second I got from this article, which is a bit Ember specific, but makes a lot of good recommendations: https://dockyard.com/blog/2015/09/25/ember-best-practices-acceptance-t…

I’ve worked on e-commerce recs. Typically you would represent each product with a vector. Then finding similar products becomes a nearest-neighbour search over these vectors. Depending on your use-case it’s feasible now to do this search in the db using pgvector, or using something like solr/elastic which both support vector search in recent releases. You could also use something like faiss or one of the many nearest-neighbour libraries or dedicated vector search engines. (Since you are working with Elixir, you might find ExFaiss interesting [1][2][3]). But I would say that for recommendations, searching the vectors is the easy part. The main work in getting good recommendations is generating a good set of product vectors in the first place. The quality of the recommendations is directly related how you generate the vectors. You could use one of the many open-source language models to generate vectors, but typically that approach isn’t very good for product recommendations. It will just give you items that are textually similar, and this usually doesn’t give good product recommendations. To get good product recommendations you’d probably want to build a custom embedding that captures some notion of product similarity during training using some signals you get from user behaviour. E.g. things like products clicked in the same session, or added to cart at the same time, gives a signal on product similarity that you can use to train a product embedding for…

One possible solution to this problem is the Free, Open Source Software community continuing to work toward more sophisticated tech that can bridge the gap between popular server-side languages for Web Dev and native platforms. PhoneGap was a failure because it was JS running on the phone, rather than compiling to something faster and with a more “native feel”. React Native is, IMHO, not that much better (and the React ecosystem has ridiculous fragmentation and churn). Flutter seems cool, but Dart is not a popular server-side language (and from what I heard anecdotally, Flutter also has API complexity and churn). Personally, I think Elixir is a natural choice for this kind of task (disclosure: I am incredibly biased in my love for Elixir). Macro-based DSLs are not beloved by all, but they can take you pretty far with minimal overhead, since you can theoretically target multiple platforms without even having to ship a custom runtime to the phone. Aside from the language itself, there is a great community, less fragmentation and churn, and a tendency to build thoughtful, robust libraries and frameworks with good docs. For inspiration, take a look at Mitch Hanberg’s Temple project[0] which compiles valid Elixir code to something that eventually gets turned into HTML. DockYard is also doing really cool, bleeding edge stuff with LiveView Native[1], even if it’s a bit early to predict how viable it will be for large, complex apps. If we can have a way to build efficient,…

Consider these two scenarios. 1. SPA with asynchronous server communication. A button switches to a spinner the moment you click it, and spins until the update is safe at the server. Error messages can show up near the button, or in a toast. 2. LiveView where updates go via the server. The button shows no change (after recovering from submit "bounce" animation) until a response from the server has come back to you. To do anything better, you need to write it yourself, and now you're back in SPA world again. There's a reason textarea input isn't sent to a server with the server updating the visible contents! Same thing applies to all aspects of the UX. EDIT: https://dockyard.com/blogs/optimizing-user-experience-with-liveview talks about this. That'll handle things like buttons being disabled while a request is in flight, but it won't e.g. immediately add new TODO items to the classic TODO list example.

> An SPA done right offers amazing interactibily and instant navigation to new views. You already have the templates cached. They probably load from a cdn with good caching policy. Most of the time I find the initial delay loading/parsing the js to be more problematic than the often tiny speed increase of subsequent loads. Furthermore, these days it takes minimal to no tweaking to get server-side rendered pages to load fast enough to barely notice the difference (in particular if the client-side is retrieving and parsing JSON in the background through an API request). Perhaps non-webdevs are even less likely to notice this stuff. > If done well you can totally run offline. That's definitely an advantage, but most SPAs I encounter don't offer offline functionality, or it's entirely unnecessary to offer it. > Sure you can build with php, laravel, django. The promise of SPA is a clean separation of UI from the APIs. The same REST APIs that external customers use is the same API you develop on. See travis-ci as an example. It’s the same api that the mobile apps can use. In some cases that's definitely an advantage. But it's entirely feasible to build an API-based backend and use that API internally for server-side rendering. If you want an app that plays nice with search engines you have to do this anyways. > This separation allows the api to return very lightweight stateless responses. You can scale much better when there is less state kungfu. That doesn't make sense…

I would say it's about developer happiness while coding and that all the decisions made by Jose and the core team tend to have been the correct decision. So taking Phoenix as an example you look at the framework and every time they find a problem i.e. Presence instead of saying that's a difficult problem and moving on they fix said problem in a really scalable way [1]. The same could be said for things like data processing with Flow [2] or even things like Ecto (semi official database wrapper) or even third party libraries like say ex_money [3]. Then you start looking at the packages and language and see that there are rarely thousands of bugs or that the infrastructure (mix, hex, docs etc.) is really nice to use and that the language is really stable, yet still provides you with useful but clear abstractions. Or that you can spin off processes and tasks inline without too much worry, or that you can use 20+ years of Erlang libs transparently, or that it's immutable and has the best concurrency primitives of any system available, or that it allow you to supervise processes and let them crash if needed without bringing down your app, or that you can transparently get multi machine out of the box, or that message passing is build in as the default way to scale the system. Or pattern matching or |> or the amazing community. [1] https://phoenixframework.org/blog/the-road-to-2-million-websocket-conn… and…

DockYard | Multiple Job Openings | Full-Time | Remote (United States) Current openings: - HTML/CSS Specialist (Engineering) - Ember Developer (Engineering) - Ruby on Rails Developer (Engineering) - Content Manager - Project Manager Listings and Application for all positions here: https://hire.withgoogle.com/public/jobs/dockyardcom DockYard is a software consultancy that helps companies design, engineer, and iterate on their most important digital products. Our team is smart, relatable, and deeply knowledgeable about modern application architecture and UX. We work alongside teams building beautiful, functional web applications with an eye toward the future. We're driven by creating exceptional user experiences, whether that be through Progressive Web Apps, well functioning data applications, or innovative front end design. We specialize in Ember, Elixir/Phoenix, UX/UI and Progressive Web App development. You can learn more about at us https://www.dockyard.com

Curious to hear if anyone have experience using Svelte together with LiveSvelte [0], as described in this blog post [1]? In theory, it sounds like this could be the sweet-spot for using the Javascript ecosystem where its required where LiveView fall short. [0]: https://github.com/woutdp/live_svelte [1]: https://dockyard.com/blog/2024/03/14/harnessing-liveview-and-svelte-fo…

Yeah, v11 has been released recently. Totally agree about ONNX, without it I wouldn't probably even started making this library. However, something I want to try is to code the network with Nx/Axon, without using onnx. The main advantage I see moving from onnx to Axon is to take advantage of all the new cool stuff like Nx sharding: https://dockyard.com/blog/2024/11/06/2024/nx-sharding-update-part-1

I wrote my thoughts on the LiveView 1.0 release: https://dockyard.com/blog/2024/12/03/phoenix-liveview-goes-1-0

Hey! I gave a talk at Code BEAM Europe this past year about our experience with a year of machine learning on the BEAM [1]. That is, the impact on our business of going 'all in' on Elixir from a more fragmented stack (Python for ML and ETL). We actually did this twice, once in 2020 from a JS front end/Elixir back end to LiveView, then again in 2022 for the ML/ETL stuff. We benefitted massively on both occasions. I recently sat down with Brian Cardarella at DockYard to talk about this and they wrote up some posts about it [2]. [1] https://www.youtube.com/watch?v=HP86Svk4hzI [2] https://dockyard.com/blog/2024/02/06/5-benefts-amplified-saw-switching…

I feel like the biggest problem is most COBOL code is heavily tied to the mainframe it's running on [1]. There are already ways of compiling COBOL code with a modern compiler [2]. There are also multiple other translation projects: https://dockyard.com/blog/2021/08/10/what-if-coboltoelixir https://www.microfocus.com/en-us/products/visual-cobol/overview [1] https://www.ibm.com/docs/en/zos-basic-skills?topic=zos-cobol-relations… [2] https://gnucobol.sourceforge.io/

> Firefly compiles Elixir applications faster and more efficiently than the BEAM can, and introduces WASI targeting to run applications in resource-constrained environments. https://dockyard.com/blog/2022/09/01/dockyard-r-d-firefly-optimizes-yo… Containers are already solved, its trivial to build and boot a mix release - but whether that's appropriate for a CLI tool depends on the complexity of the tool I guess, but not too far from flatpaks etc no?

That's one of the goals of Firefly[1] > It can compile code more efficiently than the BEAM by stripping out dead code and compiling only what’s necessary for an application. Though, they only mention faster compilation and smaller digital footprint, not faster startup. [1] https://dockyard.com/blog/2022/09/01/dockyard-r-d-firefly-optimizes-yo…

If this is like react native except where most of the logic is server-side (but sends down some kind of native DOM that gets rendered natively), I'm sold. This seems to be a more detailed link: https://dockyard.com/blog/2022/09/01/dockyard-r-d-build-elixir-web-nat…

Sure! Basically, the idea is that rather than requests in JavaScript going through an API, each user connection is maintained by a lightweight process on the server (which Elixir can scale easily), and then interactions with the page are pushed as a diff via WebSockets and then magically merged into the DOM. Interactive pages, no JavaScript required. I'm still pretty new to it, but after learning the ropes it's seeming very productive, and most importantly, fun. https://dockyard.com/blog/2018/12/12/phoenix-liveview-interactive-real…

I'm not sure about the largest-scale single usage but the Phoenix Framework uses CRDTs for handing user presence. It isn't enabled by default but it is very easy to use and the CRDT backend is basically hidden away. More info: - https://hexdocs.pm/phoenix/presence.html - https://dockyard.com/blog/2016/03/25/what-makes-phoenix-presence-speci…

You can use alpine.js. There is even a way to integrate it with LV: https://dockyard.com/blog/2020/12/21/optimizing-user-experience-with-l…

In the Phoenix LiveView world, the solution has been to use Alpine.js for user interactions that don't involve loading data from the server [1]. Alpine and LiveView are the AL in the "PETAL stack" [2] [1] https://dockyard.com/blog/2020/12/21/optimizing-user-experience-with-l… [2] https://changelog.com/posts/petal-the-end-to-end-web-stack

I bet it is similar to Phoenix Live View: https://dockyard.com/blog/2018/12/12/phoenix-liveview-interactive-real… Which would be a big deal, indeed.

That's a big topic. The shortest way I can summarize it though: Immutable data, heap isolated by concurrent process and lack of shared state, combined with supervision trees made possible because of extremely low overhead concurrency, and preemptive scheduling to prevent any one process from taking over the CPU...create that operational consistency. It's a combination of factors that have gone into the language design that make it all possible though. Very big and interesting topic. But it does create a significant capacity increase. Here's a simple example with websockets. https://dockyard.com/blog/2016/08/09/phoenix-channels-vs-rails-action-…

This might be outdated but should give you some idea at least https://dockyard.com/blog/2016/08/09/phoenix-channels-vs-rails-action-…

I have an app like that, but I found it convenient to use Phoenix anyway as it provides test helpers, a nice router, an efficient template (EEx) compiler with escaping, etc. I just ignore the parts I don't need. Phoenix LiveView looks super interesting for simplifying this further: https://dockyard.com/blog/2018/12/12/phoenix-liveview-interactive-real…