# "At present, Julia is a/an \_\_\_\_\_\_\_\_ programming language. " Fill in the blank with the most appropriate adjective

**URL:** <https://discourse.julialang.org/t/at-present-julia-is-a-an-programming-language-fill-in-the-blank-with-the-most-appropriate-adjective/134155>\
**Category:** Community\
**Created:** [November 27, 2025, 5:24am UTC](https://discourse.julialang.org/t/at-present-julia-is-a-an-programming-language-fill-in-the-blank-with-the-most-appropriate-adjective/134155 "2025-11-27T05:24:25Z")\
**Posts on this page:** 1\
**Showing post:** 28

<div class="post-metadata">

**Author:** ![Tamas\_Papp](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/tamas_papp/32/25949_2.png) [@Tamas\_Papp](https://discourse.julialang.org/u/Tamas_Papp)\
**Post date:** [December 2, 2025, 9:08am UTC](https://discourse.julialang.org/t/at-present-julia-is-a-an-programming-language-fill-in-the-blank-with-the-most-appropriate-adjective/134155/28 "2025-12-02T09:08:31Z")

</div>

> [@Eben60](#):
>
> For simple applications, there is no need to delve into the language intricacies, and the “basic Julia” is logical enough, and also similar enough to Python & Co. The beginners might struggle with understanding the scope, but apart from it?

Unfortunately, unless one just uses Julia as a generic Algol 60-like language (it has functions, control flow, …) without performance requirements, it is very easy to run into issues that require some experience and investment to solve.

As an experienced Julia user you are probably aware of all of these, but at the same time your experience makes it easier to avoid or fix them without a second thought.

To be concrete, let me give an example. The other day a student asked me for help with optimizing a calculation. Since it involved lots of small matrices, I immediately suggested using `StaticArrays.SMatrix`. The student then did something not unlike this MWE:

```julia
using StaticArrays

struct Foo{T,N}
    bar::SMatrix{N,N,T}
end

```

Now, seasoned Julia users can spot the problem quickly, which is easy to demo with

```julia
julia> baz(foo::Foo) = sum(foo.bar)
baz (generic function with 1 method)

julia> foo = Foo(SMatrix{3,3}(zeros(3,3)))
Foo{Float64, 3}([0.0 0.0 0.0; 0.0 0.0 0.0; 0.0 0.0 0.0])

julia> @code_warntype baz(foo)
MethodInstance for baz(::Foo{Float64, 3})
  from baz(foo::Foo) @ Main REPL[10]:1
Arguments
  #self#::Core.Const(Main.baz)
  foo::Foo{Float64, 3}
Body::Any
1 ─ %1 = Main.sum::Core.Const(sum)
│ %2 = Base.getproperty(foo, :bar)::SMatrix{3, 3, Float64}
│ %3 = (%1)(%2)::Any
└── return %3

```

The problem is that `SMatrix{3,3,Float64}` is _not_ a concrete type, it is `SMatrix{3,3,Float64,9}`.

Now imagine that you are a novice Julia user and this is buried deep inside 2k LOC, not a 3-line MWE you can just eyeball. You need to be aware of the tooling to discover where the problem is. Even better, set up CI with JET, and other QA tools. But then you are waist deep in… better call it experience.

Julia is immensely powerful, but if you want the performance, you cannot separate a “basic” part. It has rough edges and unravels quickly.

---

_[View the full topic](https://discourse.julialang.org/t/at-present-julia-is-a-an-programming-language-fill-in-the-blank-with-the-most-appropriate-adjective/134155)._