Nice to see this passed around on Hacker News. I think the whole concept of lenses is super cool and useful, but suffered from the usual Haskellificiation problems of being presented in an unnecessarily convoluted way.I think Accessors.jl has a quite nice and usable implementation of lenses, it&#x27;s something I use a lot even in code where I&#x27;m working with a lot of mutable data because it&#x27;s nice to localize and have exact control over what gets mutated and when (and I often find myself storing some pretty complex immutable data in more &#x27;simple&#x27; mutable containers)

Certain aspects of this me of the modf macro for Common Lisp:<a href="https:&#x2F;&#x2F;github.com&#x2F;smithzvk&#x2F;modf" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;smithzvk&#x2F;modf</a>You use place syntax like what is used with incf or setf, denoting part of some complex object. But the modification is made to the corresponding part of a copy of the object, and the entire new object is returned.

To be clear, cambria is not mine&gt; So this yaml needs to be parsed and interpreted and the applied to the target data. The rules that are allowed to be used in the yaml format must be defined somewhere.I wasn&#x27;t trying to get into the specific technology. The Julia still needs to be parse, and while Yaml has them separate, CUE does not (which is where I write things like this and have building blocks for lenses [1], in the conceptual sense)In the conceptual sense, or at least an example of one, lenses are about moving data between versions of a schema. It sounds like what you are describing is capable of this as well? (likely among many other things both are capable of)[1] <a href="https:&#x2F;&#x2F;hofstadter.io&#x2F;getting-started&#x2F;data-layer&#x2F;#checkpoints-and-history" rel="nofollow">https:&#x2F;&#x2F;hofstadter.io&#x2F;getting-started&#x2F;data-layer&#x2F;#checkpoint...</a>

Yes lenses are pairs of functions that allow bidirectional data transformations. One function acts like a getter and one function acts like a setter. The signatures of the functions are designed to compose nicely.
This allows to compose complex transformations from a few simple building blocks.In the end it is really just function composition but in a very concise and powerful way.In your cambria example the lens is defined as yaml. So this yaml needs to be parsed and interpreted and the applied to the target data. The rules that are allowed to be used in the yaml format must be defined somewhere.
With pure functional lenses the same kind of transformation rules can be defined just by function composition of similar elemental rules that are itself only pairs of functions.

It&#x27;s about the annotation triggering a code pre-processor.For example in Lombok, the @Data annotation will create a getter and a setter for every private member, and @Getter and @Setter will do the individual methods respectively.Annotating a class will do every private member, or you can annotate a specific member.A lens is a shortcut to making a getter&#x2F;setter for something several elements deep, where instead of calling:`parentObject.getChild().setChildAttribute()`
you can call:
`parentObject.setChildAttributeViaLens()`and not need to write multiple functions in both classes, or even use multiple annotations.

Lenses make it more convenient to use immutable structs, which Julia encourages (particularly as they unlock various optimisations).

Was hoping this was data lenses, like cambria from ink&amp;switch<a href="https:&#x2F;&#x2F;www.inkandswitch.com&#x2F;cambria&#x2F;" rel="nofollow">https:&#x2F;&#x2F;www.inkandswitch.com&#x2F;cambria&#x2F;</a>Not sure how &quot;A Lens allows to access or replace deeply nested parts of complicated objects.&quot; is any different from writing a function to do the same?Julia curious, very little experience

Say you want to do obj.child.foo[3].bar += 2 but without mutation, but instead all the data is immutable and you need to do a deep copy along the path.Lenses are an embedded dsl for doing this via syntax that reads similar to to the mutable variant.
Additionally it allows to compose many of such transformations.

&gt; Your natural choice in the &quot;OOP style&quot; is to write a lot of boiler plate to point to each different field you want to get&#x2F;set.Your natural alternative to lenses in imperative languages is usually to just store a reference or pointer to the part you want to modify. Like a lens, but in-place.

The difference doesn&#x27;t matter when you have a shallow structure and can access fields directly and have a few lines of code. But field access does not compose easily if you have a nested hierarchy of objects. Your natural choice in the &quot;OOP style&quot; is to write a lot of boiler plate to point to each different field you want to get&#x2F;set. Say you get bored of the tedium and want &quot;higher-order&quot; accessors that compose well -- because ultimately all look-up operations are fundamentally similar in a sense, and you only need to write traversals once per data structure. Eg: Instead of writing yet another depth-first search implementation with for loops, you could easily tie together a standard DFS implementation (traversal) from a library, with accessors for the fields you care to work with.One way to think of the goal of functional paradigm is to allow extreme modularity (reuse) with minimal boilerplate [1]. The belief is minimal boilerplace + maximum reuse (not in ad-hoc ways, but using the strict structure of higher-order patterns) leads to easily maintainable bug-free code -- especially in rapidly evolving codebases -- for the one-time cost of understanding these higher-order abstractions. This is why people keep harping on pieces that &quot;compose well&quot;. The emphasis on immutability is merely a means to achieve that goal, and lenses are part of the solution to allow great ergonomics (composability) along with immutability. For the general idea, look at this illustrative blog post [2] which rewrites the same small code block ten times -- making it more modular and terse each time.[1] <a href="https:&#x2F;&#x2F;www.cs.kent.ac.uk&#x2F;people&#x2F;staff&#x2F;dat&#x2F;miranda&#x2F;whyfp90.pdf" rel="nofollow">https:&#x2F;&#x2F;www.cs.kent.ac.uk&#x2F;people&#x2F;staff&#x2F;dat&#x2F;miranda&#x2F;whyfp90.p...</a>[2] <a href="https:&#x2F;&#x2F;yannesposito.com&#x2F;Scratch&#x2F;en&#x2F;blog&#x2F;Haskell-the-Hard-Way&#x2F;" rel="nofollow">https:&#x2F;&#x2F;yannesposito.com&#x2F;Scratch&#x2F;en&#x2F;blog&#x2F;Haskell-the-Hard-Wa...</a>Once the language is expressive enough to compose pieces well and write extremely modular code, the next bit that people get excited about is smart compilers that can: transform this to efficient low-level implementations (eg. by fusing accesses), enforce round-trip consistency between get &amp; set lenses (or complain about flaws), etc.

It&#x27;s an interesting question, why immutability is not built into more languages as the default, so that the most intuitive syntax of assignment produces new values.Without having any expertise in the matter, I&#x27;d guess that mutability has the advantage of performance and efficient handling of memory.<pre><code> obj.foo[5].bar.a = 2
</code></pre>
An immutable interpretation of this would involve producing new objects and arrays, moving or copying values.Another possible advantage of the mutable default is that you can pass around references to inner values.

The other replies covered the answer about immutability well, but I have the further question: why isn&#x27;t this built into languages as syntax sugar, so that OP&#x27;s suggested line would work with immutable structures?As a dilettante at programming language design, I have my own toy language. It uses exclusively immutable data structures (C++ &quot;immer&quot;). I present it to the programmer as simple value semantics. `obj.foo[5].bar.a = 2` works and sets `obj` to a new structure where the path through `foo`, `bar`, to `a` has all been rewritten. Since I put it in as a language feature, users don&#x27;t have to learn about lenses. Why isn&#x27;t this technique more common in programming language design? Is it so offensive that the syntax `obj.a = 2` ends up rebinding `obj` itself? The rule in my language is that assignment rebinds the leftmost &quot;base&quot; of a chain of `.` field and `[]` array index accesses on the LHS. I&#x27;m ignorant of the theory or practical consideration that might lead a competent designer not to implement it this way.

Immutability is a central concept in functional programming.

You can uhhh abstract over the property which seems cool if you’re into abstracting things but also probably shouldn’t be the thing you’re abstracting over in application code.Or on second look the sibling comment is probably right and it’s about immutability maybe.

Counterintuitively Julia recommends the use of immutable data types for performance reasons, because immutability enables more flexible compiler optimisationsAn immutable variable can be savely shared across functions or even threads without copying.
It can be created on the stack, heap or in a register, whatever the compiler deems most efficient.In the case, where you want to change a field of an immutable variable (the use case of lenses), immutable types may still be more efficient, because the variable was stack allocated and copying it is cheap or the compiler can correctly infer, that the original object is not in use anymore and thus reuses the data of the old variable for the new one.Coming from the C++ world, I think immutability by default is pretty need, because it enables many of the optimisations you would get from C++&#x27;s move semantics (or Rust&#x27;s borrow checker) without the hassle.

It&#x27;s a similar idea to map() but for more complex objects than arrays. When people use &quot;map&quot; in Javascript (or most any other language that supports it) do they do so because &quot;they are terrified of mutability, and are willing to abandon performance?&quot;Your comment reads like the response of someone who is struggling to understand a concept.

Immutability gives you persistence, which can be practically useful. It’s not just fear.

This is equivalent to that for people who are irrationally terrified of mutability, and are willing to abandon performance.

I have to admit I don’t really understand the point of doing this instead of just obj.a = 2 or whatever.

I don’t use it for much data science, and I only have used it for one project (to speed up my dad’s Octave code), but I actually really liked it. Generally speaking things were extremely fast, even without any specific optimization on my end. Like, without hyperbole, a direct port of my dad’s code was between 50-100x faster in most cases, and when I started optimizing it I ended up getting it going about 150x faster.There was a bit of weirdness with the type system with its dynamic dispatch making things slow, but specifying a type in function headers would resolve those issues.I also thought that the macro system was pretty nice; for the most part I found creating custom syntax and using their own helpers was pretty nice and easy to grok.Since I don’t do much data work I haven’t had much of an excuse to use it again, but since it does offer channels and queues for thread synchronization I might be able to find a project to use it for.

I guess you had a bad experience, but this hasn’t been an issue for me using it for many years now.

I don&#x27;t quite understand what your issues were, I don&#x27;t have any with the current module system <a href="https:&#x2F;&#x2F;docs.julialang.org&#x2F;en&#x2F;v1&#x2F;manual&#x2F;modules&#x2F;" rel="nofollow">https:&#x2F;&#x2F;docs.julialang.org&#x2F;en&#x2F;v1&#x2F;manual&#x2F;modules&#x2F;</a>Can you provide some concrete examples of that issues existing today?

I&#x27;ve worked in about 40 languages and have a Ph. D. in the subject. Every language has problems, some I like, some I&#x27;m not fond ofThere is only one language that I have an active hatred for, and that is Julia.Imagine you try to move a definition from one file to another. Sounds like a trivial piece of organization, right?In Julia, this is a hard problem, and you can wind up getting crashes deep in someone else&#x27;s code.The reason is that this causes modules that don&#x27;t import the new file to have different implementations of the same generic function in scope. Julia features the ability to run libraries on data types they were never designed for. But unlike civilized languages such as C++, this is done by randomly overriding a bunch of functions to do things they were not designed to do, and then hoping the library uses them in a way that produces the result you want. There is no way to guarantee this without reading the library in detail. Also no kind of semantic versioning that can tell you when the library has a breaking change or not, as almost any kind of change becomes a potentially-breaking change when you code like this.This is a problem unique to Julia.I brought up to the Julia creators that methods of the same interface should share common properties. This is a very basic principle of generic programming.One of them responded with personal insults.I&#x27;m not the only one with such experiences. Dan Luu wrote this piece 10 years ago, but the appendix shows the concerns have not been addressed: <a href="https:&#x2F;&#x2F;danluu.com&#x2F;julialang&#x2F;" rel="nofollow">https:&#x2F;&#x2F;danluu.com&#x2F;julialang&#x2F;</a>

Drawback, it isn&#x27;t Python in community scale, remember it was born in 1996, so it had enough time to grow.Advantages, it is yet another Lisp like language in a Algol like syntax, like Dylan and Wolfram Alpha, also another one with multi-methods support a la Common Lisp, Dylan, Clojure, and whoever else implements a subset of CLOS.It was designed from the ground up to be compiled with a JIT, not as an afterthought.These are the kinds of places making use of it,<a href="https:&#x2F;&#x2F;juliahub.com&#x2F;case-studies" rel="nofollow">https:&#x2F;&#x2F;juliahub.com&#x2F;case-studies</a>

If you’re young, new to data science and hoping to get a job in it after some time, then I absolutely recommend learning Python instead of Julia.But if you are just interested in learning a new language and trying it in data science OR are not currently looking to enter the data science job market, then by all means: Julia is great and in many ways superior to Python for data science.It’s just that «everyone» is doing data science in Python, and if you’re new to DS, then you should also know Python (but by all means learn Julia too!).

As for the tooling, julia-snail on emacs is supposed to be like SLIME for Lisp. But sounds like that isn&#x27;t your main gripe. Having to load so many packages is a indeed a pain, but it does suggest the core language is rather minimal...

I would love to love it, but for now I hate to hate it.Dynamic yet performant language with LISPy features and focus on numerical applications? Count me in.But then I found out that execution of some ideas is rather bad, and some ideas are great on paper, but not in practice. For example, debugging experience is a joke even compared to SBCL debugger (and you of course need to download package Debugger.jl, because who needs a good debugger in base language implementation?) And multiple dispatch is a very powerful feature... I sometimes think it is too powerful.There is no proper IDE, and VSC extension was slow and unstable when I tried it (last time few months ago).But my biggest gripe is with people developing Julia. Throughout the years every time people complained about something (&quot;time to first plot&quot;, static compilation etc.) the initial responses were always &quot;you are holding it wrong&quot;, &quot;Julia is not intended to be used this way&quot;, &quot;just keep you REPL open&quot;, &quot;just use this 3rd party package&quot;, only to few releases later try to address the problem, sometimes in suboptimal way. It is nice that in the end they try to deliver solutions, but it seems to me it always require constant push from the bottom.Moreover, I am quite allergic to marketing strategies and hype generation:Julia doesn&#x27;t run like C when you write it like Python. It can be very fast, but then it requires quite detailed tuning.You don&#x27;t need to think about memory management, until you need to, because otherwise allocations kill your performance.You can omit types, until you can&#x27;t.Those things are quite obvious, but then why produce so much hype and bullshit people through curated and carefully tuned microbenchmarks?It maybe solves two-language problem, but in return it gives you million packages issue. You need a package to have a tolerable debugger (Debugger.jl), you need a package to have static and performant arrays (StaticArrays.jl), you need a package to have enums worth using, you need a package to hot-reload your code without restarting REPL (Revise.jl), you need a package to compile you code to an executable (PackageCompiler.jl&#x2F;StaticCompiler.jl, they started to address that in the last release) etc. And then you need to precompile them on your machine to have reasonable startup time.TLDR: Julia is wasted potential.

As a language, Julia is strictly superior to Python in many ways (e.g., it&#x27;s easy to write multithreading code). Currently Python still can be preferable due to its huge ecosystem and super optimised libraries for data science. But Julia is catching fast.

Guys, What&#x27;s you&#x27;re opinion on Julia?I am thinking of using it for data science work.Any draw backs? or advantages I should know about?

In the release 1.12 they finally implemented the ability to create compact executables, so I would say the answer to your question is &quot;yes&quot;.

Is Julia a general purpose programming language? I mean I did check the web site which contains a &quot;General Purpose&quot; section, yet the articles seem to center around &quot;scientific applications&quot;.

In the simplest case, yes, but in general no, lenses are more general

Lenses in Julia