Talk:Julia (programming language)

Checked overflow support on all integer operations, allowed now. Reworked some more of this text that I deleted earlier.

In Julia all data types are supported in a completely general way (not needing manifest typing, that is optional); even those commonly implemented in processors, such as integers (signed and unsigned) from 8-bit to 64-bit, defaulting to signed 32-bit or 64-bit depending on CPU architecture (and additionally 128-bit and arbitrary-precision arithmetic "BigInt", which are slower as not supported in hardware by CPUs); all common/fast floating-point types up to 64-bit/"double" (and a package bigger using the double-double arithmetic trick), even decimal floating-point type (not supported in hardware by x86/ARM CPUs etc. requiring software emulation) in a package Decimals.jl. In general, all types, whether built-in or not, are treated the same, with "no abstraction penalty" (while software emulation, would necessarily slow down, when CPUs support a type if Julia wouldn't). While CPU registers bigger than 64 bits are available in CPUs, such as in x86, they are SIMD-style vector registers of many 32-bit values (or smaller), also supported in Julia at high speed (might in some cases need the @simd macro).

Complex numbers are supported by the language.

Julia uses efficient "machine integers" (e.g. modular numbers), not checking overflows (does for floating point), by default, while separate functions allow that. "integer arithmetic overflow" is discussed for addition by version 1.0 and at JuliaCon 2014, but may or may not end up being the default. The performance section of Julia's manual justifies non-checked machine integer use (that is faster), compared to saturated (that e.g. MATLAB uses), or exceptions on overflow. Julia however has "checked integer conversions" in 0.4.0-rc3. comp.arch (talk) 09:07, 9 December 2015‎ (UTC)

References

Excessive detail/difficult readability

In my opinion, while the facts in this article are all fairly well-sourced, the article contains way too many esoteric details that are of little use to most people. These details are often in parentheses, sometimes nested parentheses, with "e.g." and "i.e.," and that in turn makes it hard to even follow the original text. This type of writing style is unlike most other articles I have encountered on this site. Take this paragraph in the introduction:

• "Several development tools support coding in Julia, such as integrated development environments (e.g. for Microsoft's Visual Studio Code, an extension is available providing debugging and linting support); with integrated tools, e.g. a profiler (and flame graph support available for the built-in one), debugger, and the Rebugger.jl package "supports repeated-execution debugging" and more."

All that this paragraph really needs to say is that there is linting and debugging support in IDEs for the language. Mentions of VS Code, the flame graph, and whatever Rebugger.jl is doing are details which should be in a section further down or omitted altogether save their citations. I am of the opinion that the entire paragraph should be removed from the intro because it does not concern the language itself, but rather third-party tools.

As far as I understand, Julia's support for compilation to binary executables is still experimental, and not really a core feature of the language - does it really deserve a paragraph in the intro?

As another example, take the list in the history section with the version numbers 1.1, 1.2, etc. Given that the 1.X is a stable version of the language, this seems like a list that could be cleaned up by simply mentioning the most important features that have been added since the 1.0 release, such as the multithreading from 1.3. Those sentences about 1.7+ being time-based releases or 1.7.3 shouldn't be there at all - aren't all patch releases "fixing some issues?" And who cares about time-based vs. feature-based? There are also multiple sentences in this section mentioning the details regarding performance improvements or things done to reduce compiler latency when it could really be boiled down to one or two sentences about how the developers have been focusing on the problem more generally.

Here's a draft of how I would write the history section, starting after the Bezanson quote and up to the sponsors subsection:

Julia 1.0 was released on 8 August 2018 with the syntax stabilized. Since then, the language has added many new features, such as composable multithreading in version 1.3, syntax for generic array indexing in 1.4, and an improved random number generator in 1.7. The releases have also gradually improved compiler latency and package loading times, i.e. the "time-to-first-plot" performance.

Three of the Julia co-creators are the recipients of the 2019 James H. Wilkinson Prize for Numerical Software "for the creation of Julia, an innovative environment for the creation of high-performance tools that enable the analysis and solution of computational science problems." Alan Edelman received the 2019 IEEE Computer Society Sidney Fernbach Award "for outstanding breakthroughs in high-performance computing, linear algebra, and computational science and for contributions to the Julia programming language."

Since 2014, the Julia community has hosted an annual conference (JuliaCon) focused on developers and users. The conferences have taken place across a number of locations including MIT and the University of Maryland, Baltimore. JuliaCon was conducted virtually from 2020 to 2022 due to the COVID-19 pandemic. The event audience has grown from a few dozen people to over 43,000 unique attendees during JuliaCon 2021. The conferences have featured keynote addresses from notable individuals such as William Kahan (the primary architect of the IEEE 754 floating-point standard) and Soumith Chintala (co-creator of PyTorch).

It's much shorter, but it's also more readable and obviates the need for the reader to wade through the details of changes made to the language which could be easily accessed in their release notes. This would of course be a major edit, so let me know your thoughts. Eulalie880 (talk) 21:36, 12 November 2022 (UTC)

I'd be happy to see these edits merged! Closed Limelike Curves (talk) 03:00, 10 November 2023 (UTC)

I agree the article doesn't really adhere to Wikipedia standards: a) often lacking independent sources, b) including content that is of questionable relevance, partially because it has not been mentioned in any independent sources, c) overly long, d) potentially overly positive, it doesn't list disadvantages/challenges of Julia. I could hardly find anything critical in the article, while there's plenty on the internet (yes potentially not super reliable sources [I haven't checked] but most of this article is just what Julia org says about Julia lang. Example criticism: https://www.reddit.com/r/Julia/comments/11ucqtz/whats_julias_biggest_weakness/, https://yuri.is/not-julia/, https://jamesmccaffrey.wordpress.com/2021/06/15/why-im-not-a-fan-of-the-julia-programming-language/ AncientWalrus (talk) 17:51, 30 January 2024 (UTC)

Reads like advertising

What it says. Sorry, but it does. 2601:1C0:5401:2040:5CCB:C27C:F135:5733 (talk) 04:12, 5 September 2023 (UTC)

Yeah, I mostly just glanced at the article but the sentence "Julia programs can also be (separately) compiled to binary executables, even allowing no-source-code distribution, and the executables can get much smaller with Julia 1.12." stuck out to me. Do we really need to list that 1.12 can produce smaller executables? That reads more like an ad than something belonging in an encyclopedia. Kittybwained (talk) 00:52, 27 January 2025 (UTC)

Currently compiled apps are huge, why 1.12 is mentioned, i.e. upcoming juliac tool in there, and its binaries are small. Yes, 1.12 isn't released yet as stable, but it is usable in beta form so I thought mentioning its capabilities was ok. Feel free to just change. comp.arch (talk) 14:09, 14 April 2025 (UTC)

Where it can run table (compatibility)

It would be good to know on what platforms and version Julia can run on in a table, eg Windows, macOS, linux, iOS, Android, ... The table would probably need an explanation of any specific tools needed (frameworks, compilers). Also whether packaged packaged apps can be built that can be distributed (eg app store) to users without users requiring anything else to be installed.

An explanation of how features unique to each platform can be accessed would be useful. FreeFlow99 (talk) 16:55, 6 March 2024 (UTC)

FYI, there's no support tier for Android (or iOS), so everything for it is unofficial, and while possible to do, arguably non-ideal, at least currently. Julia can run on all the supported platforms, best if tier 1 support, all those desktop OSes you mention. No tools are needed except for Julia. But if you want precompiled, it's a more complex answer, and the (main) tools for that are mentioned in the article. Feel free to clarify the article or ask questions here. comp.arch (talk) 14:06, 14 April 2025 (UTC)

Robust edits to address feedback

I'm looking to do fairly major rewrites of sections to address a number of the justified critiques on this talk page, with a focus on increasing readability, a balanced tone and inclusion of reliable independent sources. Happy to discuss here or on my talk page User:Jfo17 Jfo17 (talk) 04:31, 18 July 2025 (UTC)