I would like to see a scenic-like solution for desktop apps that is based on a NIF which uses the same crates as in zed code editor. This way we would have a native desktop apps that are rendered using by GPU where each UI component could have it’s own beam process.

IMO the biggest thing missing from the ecosystem is a proper database. Mnesia doesn’t cut it, so we’re all left using Postgres et al which feels like a total waste of the BEAM’s potential.

I actually started an experimental side project in this area several months ago and it has been going surprisingly well. Will have to make a post about it soon.

TLDR: There was no copyright issue. I own the copyright to the logo, and the agency’s claims were baseless. After I hired a law firm to analyze the situation, they confirmed my position. The agency CEO has agreed to issue a public apology on LinkedIn.

Longer version:

For those unaware of the situation: After releasing Hologram, I announced it on LinkedIn with our project logo and name. Shortly after, the CEO of a design agency publicly accused me of stealing both their company name and logo. Instead of reaching out privately first, he sent me an email demanding I change the project’s name (and the logo).

The situation was quite stressful. I released Hologram at around 3-4 AM and announced it on various platforms, and his aggressive accusations were literally the first thing I saw when I woke up. What made it worse was that his employees then flooded the LinkedIn announcement thread, engaging in public shaming and bullying behavior.

The logo concept itself is based on common iconography - a minimalist representation of a 2D projection of a hologram machine projecting a hologram. While it’s true that one element of the logo (the icon) is similar, the text treatment is completely different, and they typically only use text in their branding anyway. More importantly, there are thousands of companies and GitHub projects using “Hologram” in their names, and the agency doesn’t hold any trademark rights.

I took this seriously and hired a law firm specializing in trademarks and patents. They thoroughly analyzed the situation and confirmed that the agency’s claims were completely unreasonable. I have clear documentation proving independent creation of our logo and hold the copyright.

The CEO has since removed his LinkedIn post, and we’re awaiting his public rectification. While I understand his initial reaction seeing a similar name and icon, this could have been handled much more professionally through direct communication. If he doesn’t follow through with the agreed-upon public apology, we’ll have to resolve this in court.

Interesting tidbit: After dozens of iterations and finalizing all the geometric calculations, I actually generated the final logomark using an Elixir script that outputs an SVG:

# alfa = 60 degrees
sin_alfa = :math.sqrt(3) / 2
tan_alfa = :math.sqrt(3)

x1 = 0
y1 = 0

x2 = 100
y2 = 0

x3 = 50
y3 = tan_alfa * 50

a = 18
b = a / sin_alfa

x4 = (a + b * tan_alfa) / tan_alfa
y4 = a

x5 = 100 - x4
y5 = a

x6 = 50
y6 = tan_alfa * (50 - b)

File.write!("logomark.svg", """
<svg width="100" height="#{y3 + a}" xmlns="http://www.w3.org/2000/svg">
  <path d="
    M #{x1} #{y1} L #{x2} #{y2} L #{x3} #{y3} Z
    M #{x4} #{y4} L #{x5} #{y5} L #{x6} #{y6} Z
  " fill="#a78bfa" fill-rule="evenodd" />

  <rect x="#{a}" y="#{y3}" width="#{100 - 2 * a}" height="#{a}" fill="#a78bfa" />
</svg>
""")

This whole experience has been quite draining…I appreciate your concern about this situation! @hubertlepicki

I’d suggest that this is a common misconception driven typically by past experiences with things that resemble Ash. The tools we provide work independently of data interactions (although there are some cases that you can’t put X & Y together w/o a data layer or with only certain data layers, but that is just a reality of software engineering).

This is a perfectly valid resource:

defmodule MyApp.Hello do
  use Ash.Resource

  actions do
    action :say_hello, :string do
      argument :to, :string, allow_nil?: false

      run fn input, _context -> 
        {:ok, "Hello #{input.arguments.to}"}
      end
    end
  end
end

If you want to add that to a GraphQL API:

defmodule MyApp.Hello do
  use Ash.Resource,
    extensions: [AshGraphql.Resource]

  graphql do
    queries do
      action :say_hello
    end
  end

  actions do
    action :say_hello, :string do
      argument :to, :string, allow_nil?: false

      run fn input, _context -> 
        {:ok, "Hello #{input.arguments.to}"}
      end
    end
  end
end

Or if you want to build a form for it:

# make a form
form = AshPhoenix.Form.for_action(MyApp.Hello, :say_hello)

# validate it with inputs from the client
form = AshPhoenix.Form.validate(form, %{to: "fred"})

# submit it
form = AshPhoenix.Form.submit(form)
# {:ok, "Hello fred"}

The benefits that Ash provide are that in the cases that you need persistence as you often do when building applications, you can opt into it without a bunch of choreography.

defmodule MyApp.Person do
  use Ash.Resource,
    extensions: [AshGraphql.Resource],
    data_layer: AshPostgres.DataLayer

  postgres do
    table "table"
    repo Repo
  end

  graphql do
    queries do
      action :say_hello
    end

    mutations do
      create :create
    end
  end

  actions do
    defaults [:create]

    action :say_hello, :string do
      argument :to, :uuid, allow_nil?: false

      run fn input, _context ->
        with {:ok, user} <- Ash.get(user, input.arguments.to) do
           {:ok, "Hello #{user.name}"}
        end
      end
    end
  end

  attributes do
    uuid_primary_key :id
    attribute :name, :string, allow_nil?: false
  end
end

Oftentimes folks will have resources with data layers and without.

Ash isn’t about slapping an API on top of a database. Things like calculations, generic actions (that action/3 that I showed up there), and tons of configuration for how various extensions work with your resources give you the best of both worlds in terms of simple powerful tools derived from resources, with the ability to progressively enhance as complexity increases.

Obviously I’m biased, so grain of salt and all that

Honestly I feel like the biggest things missing are not new libs/features, but improving what we already have!

For example:

• More contributors to the Elixir language server (the LSP team is very busy!)
• The Livebook ecosystem
• Improving the ergonomics of Telemetry, debugging, and performance optimization tools