Threads for glacambre

  1. 8

    Company: AdaCore

    Company site: https://www.adacore.com

    Position(s): GCC/GNU Toolchain Developer, DevSecOps Developer, QA Engineer, Software Supply Chain Engineer, Product Security Engineer, IT Systems Engineer.

    Location: Some positions are available remotely, others are in Paris/Grenoble/Toulouse/Vannes in France, the Product Security Engineer one is in Dresden in Germany.

    Description: AdaCore’s original mission was to maintain GNAT, GCC’s Ada frontend. The company quickly expanded and is now maintaining a lot of tools revolving around the Ada ecosystem (build systems, other backends for GNAT, IDEs, various parsing technologies, static analysis tools, formal proof tooling, embedded runtimes…). Everything we do is open source and we make money by selling support, trainings, certification etc.

    Tech stack: Depends a lot on the position, but knowing Ada is not a requirement (AdaCore can even provide trainings in the language if necessary). If you’re going for the Release Engineer, DevSecOps or Software Supply Chain Enginner positions, you’ll likely need Python.

    Compensation: Depends on the position and experience. AdaCore seems to pay an average salary from what I can tell.

    Contact: Please go through the webpage dedicated to the position you’re interested in.

    1. 34

      They want to make their own class system modeled on Java? I think I like the NeoVim approach of using existing languages more.

      1. 6

        I don’t mind them adding to the vimscript language. This path means existing scripts can be upgraded piecemeal without needing a total rewrite.

        1. 11

          Gradual upgrades to lua are also fairly easy in neovim, since every lua function is available through v:lua on the vimscript side, every vimscript function is available through vim.fn on the lua side and conversion of datastructures between the two is almost seamless.

          1. 7

            FWIW I’ve been using vim9script on and off for the last 6 months. I’ve enjoyed it a lot more than I’ve enjoyed using lua. The type systems hits a nice sweet spot for the use case. It is very similar to typescript 1.0. For app development I can see why typescript has evolved such an extensive type system. For vim plugins it has been nice to work with a system that doesn’t tempt you to get too specific just for the sake of specificity.

            1. 6

              I can believe that :). I’ve heard of people programming neovim plugins in Teal, which as far as I understand is supposed to be to lua what typescript is javascript, perhaps you’d like it?

              As far as I’m concerned, I find writing neovim plugins much nicer than writing vim plugins due to the APIs making much more sense and being better designed in general.

        2. 5

          Fun fact: you can use lua in vim too. Also python. Also ruby. Also tcl. vim9script is just another language you can opt into.

          1. 13

            NeoVim has better support for Lua in the sense that the language is guaranteed to be available, has a first-class API and can be directly used for configuration (init.lua, ftplugin/*.lua, etc.).

            1. 6

              You can’t rely on these languages always being there though as Vim can be compiled without them. I believe this is the reason why non-vimscript plugins for Vim never really took off. If you still think these languages count, then you should probably also think that Neovim can have plugins written in any programming language. Its language-agnostic RPC mechanism has access to almost all of the APIs the embedded lua interpreter has access to. There’s a bunch of Neovim plugins written in python, typescript and Rust, and lots of Neovim GUIs written in a variety of languages.

              1. 4

                Sure, there’s some headaches there in theory. However in theory you can also compile vim without support for vimscript and that concern hasn’t prevented it’s adoption. In practice the various distributions almost universally build in support for vimscript. Likewise they almost universally build in support for auxiliary languages too. I’ve personally relied on python plugins that worked with the windows, macos, and debian distributions.

                I’m not particularly interested in convincing anyone about the capabilities of neovim, either positive or negative. My comment was meant simply to reject the suggestion that adding classes to vim9script was at odds with bolstering support for other languages.

                1. 5

                  You’re right, I took your comment out of context, sorry about this and thanks for noticing :)

          1. 2

            As always a very nice and elaborate writeup of the changes for Ada 2022. Every feature in Ada feels well-thought-out and fits into place, which leads to a high consistency.

            Without specific mentions, big parts of the language community can learn a lot from how AdaCore et. al. do their language development.

            1. 2

              Agreed. Wish more people use it for software development

              1. 2

                Without a permissively licensed compiler, it’s hard to recommend the language. AdaLabs was trying to build an Ada front end for LLVM, but I don’t think they made progress.

                1. 2

                  I’m not up to date on my Ada, but what’s the problem with GNAT?

                  1. 2

                    What’s the problem with a GPLv3 compiler? The FSF’s GNAT/GCC license allows linking the runtime with proprietary software.

                    1. 1

                      If any of your workflow involves distributing the compiler (for example, if you want to create a developer container to allow quick onboarding for a project) then you need to comply with all of the GPLv3 conditions. If you own any patents, for example, then you must carefully audit the code to ensure that no one has snuck in any code that infringes them because otherwise you’ve just accidentally granted everyone a perpetual license. This is why a lot of companies have a no-GPLv3-code policy. In some cases, it’s more liberal (you can use, but not contribute back to or redistribute), but in a modern world using code that you can’t redistribute is painful. You also can’t use the compiler front end in any additional tooling unless you’re willing to release under a GPLv3-compatible license.

                      I don’t mind having a GPL’d or proprietary compiler as a second source but I wouldn’t want to build a business depending on it.

                      1. 3

                        If any of your workflow involves distributing the compiler

                        I was going to write a rebuttal, but thinking more about it this is a valid point. However here are a few things that I think weaken it:

                        • Distributing the compiler is a very niche use case that I don’t see many businesses need (and in the case of GNAT, I’d argue that paying AdaCore to do it is a better use of money/engineer time since their business literally is maintaining and distributing GNAT).
                        • A successful stage 3/4 bootstrap from a clean environment (e.g. a VM) is a fairly strong guarantee that you’re not shipping anything you don’t want to leak.
                        • GCC frontends usually are a poor fit for creating new tooling anyway. In the specific case of Ada, you should go with libadalang (soon to be re-licensed under Apache 2.0) instead.

                        So overall, despite it being correct, I don’t find your argument about finding it hard to recommend Ada due to the main compiler being GPLv3 very convincing :). Still, this was interesting to think about, thanks for sharing your point on view!

                        1. 2

                          Distributing the compiler is a very niche use case that I don’t see many businesses need

                          I think that absolutely was true a year ago, but it increasingly isn’t. A lot of development is now moving to containers, where you provide a container layer with all of your default tooling so that folks can easily contribute to your project. Even if your project is closed source, you may distribute this to consumers and so on. Similarly, you will distribute it to the folks running any outsourced CI system and so on.

                          A successful stage 3/4 bootstrap from a clean environment (e.g. a VM) is a fairly strong guarantee that you’re not shipping anything you don’t want to leak.

                          That doesn’t help. The issue is:

                          • I file a patent on technique A that I don’t want competitors to use.
                          • Someone contributes an infringing patch to GNAT.
                          • I distribute GNAT.
                          • I sue someone else for infringing my patent.
                          • The person points to the implementation of A in GNAT and I discover that I’ve accidentally licensed it.

                          This is why big companies are incredibly wary about distributing GPLv3 code. A clean-room build doesn’t solve this, only a complete code audit does and that’s too expensive.

                          The fact that it’s GPLv3 and an FSF project also makes me much more hesitant because the FSF relicensed GCC from a license that was mostly fine to a license that had a bunch of things that made corporate lawyers nervous. I have no idea what GPLv4 will look like and if I have to either fork GCC or migrate to a different compiler when GCC 15 moves to GPLv4, that’s not something I want in my long-term risk planning.

                    2. 2

                      What is the importance of a permissively licensed compiler?

                      1. 1

                        Is there a commercial option? I’m allergic to GPL3, but commercial is OK.

                        1. 2

                          GNAT is both GPL3 and available commercially :). There’s also a bunch of other proprietary compilers, such as Green Hill’s or PTC’s. GNAT is however usually the most up to date one.

                        2. 1

                          Recently they have changed that

                          https://blog.adacore.com/a-new-era-for-ada-spark-open-source-community

                          I think LLVM one is available through alire

                          1. 2

                            GNAT-LLVM uses GNAT’s frontend, which is GPLv3 and thus contaminates LLVM, if I’m not mistaken.

                            1. 1

                              It only means that if you ship both in one distribution, the LLVM part is not allowed to be shipped in a way that gives you lesser rights than the GPLv3 part - which essentially means if someone requests the source code to their binary, they need to get it for both components. That’s quite okay.

                              The LLVM bits will still remain permissibly licensed, it’s not “contaminated”.

                              The other alternative is shipping the LLVM part as a dynamic library and the frontend separately (e.g. in 2 zip files) for the user to install independently. It’s not uncommon.

                              1. 4

                                Compilers stretch the GPL somewhat because a compiler, intrinsically, embeds some of its code in its output and so can taint the output. GCC has a specific runtime exemption for things like libgcc for this. I’m very grateful to the FSF for doing this. I flagged it as a problem when I started working on clang support for Objective-C in 2008 and realised that I would not be able to use the GCC Objective-C runtime with clang. I ended up writing an MIT-licensed replacement but the GCC project did a fantastic job writing a license exemption that allowed other compilers to use their run-time libraries. I presume all of the relevant bits of GNAT are also covered by this.

                                1. 1

                                  I understand this (I used to be in the core team of Rust, among other things dealing with licensing concerns), but that does not change depending on the GNAT frontend running on top of GCC or on top of LLVM.

                                2. 1

                                  the LLVM part is not allowed to be shipped in a way that gives you lesser rights than the GPLv3 part

                                  That’s what I meant by “contaminates” :).

                                  The other alternative is shipping the LLVM part as a dynamic library and the frontend separately (e.g. in 2 zip files) for the user to install independently. It’s not uncommon.

                                  Interesting, I didn’t know some entities actually bothered with that. I’m curious to know more, if you’re allowed to share information :).

                                  1. 2

                                    I‘m not a friend of „contamination“ language. The GPL clause involved in this triggers on distribution, but after that, you can totally go and use both components separately, under their respective licenses.

                                    Interesting, I didn’t know some entities actually bothered with that. I’m curious to know more, if you’re allowed to share information :).

                                    It‘s a common thing for distribution licenses - you go to „some assembly required“ and the user makes the free choice to assemble those things together. E.g. if you use rustc on Windows, you need to either install mingw (gnu/GPL) or Visual Studio CLI (license-encumbered, for pay for commercial applications) for the compiler to actually work. It‘s inconvenient, but keeps the „can we ship these things together“ question neatly outside of the distributors scope.

                                    The same mechanism can be used here.

                        3. 2

                          It would be nice if more languages took such care when adding new features!

                        1. 9

                          I’ve used a lot of Python and a fair amount of Common Lisp, and I’ve also never seen this problem happen in real life, mostly because data tends to “stay in its lane”, I think. But I do note that the relative safety of duck typing is mostly enforced at runtime (always at runtime for Python, maybe at compile time in CL depending on details), and people who like static languages mostly like to have those constraints enforced at compile time…

                          At $DAYJOB, I write a lot of C#, and its interfaces are mostly fine. The problem that the author of the article points out is that dealing with other people’s code, they might not have declared an interface when they should have, and you have to use a subclass instead, even where an interface might be more appropriate. I run into this a lot of the time. And back when I was writing Java, I often ran into the problem where not only did the library author not declare an interface where they should have, the class was also declared ‘final’ and couldn’t be subclassed. While this is possible in C# as well, I’ve never seen it in the wild.

                          1. 4

                            But I do note that the relative safety of duck typing is mostly enforced at runtime, and people who like static languages mostly like to have those constraints enforced at compile time…

                            Is that really true? Go, Standard ML, Ocaml, Typescript and probably a lot of other languages I can’t think of perform compile time checking of structural constraints.

                          1. 4

                            The GCC wiki can also be a good reference in order to understand some parts of GCC: https://gcc.gnu.org/wiki .

                            1. 9

                              Why is the language causing so much pain voted as “the most loved language” for like 7 years in a row in the Stack Overflow survey. Is it the Stockholm syndrome? Do Rust devs like pain? Or maybe it’s a huge cult: you get in and you try to lure in as many people as you can so they feel the pain too.

                              Yes, a cult is exactly what it is. Or to put it in less aggressive terms, people who haven’t used Rust and like what they’ve heard of it ; i.e. hype. It’s exactly the same phenomenon that caused Neovim to be the most loved text editor while also being one of the least-used ones in the most recent survey. The stackoverflow survey is a really bad datapoint IMO.

                              I also wouldn’t agree with the “Rust isn’t hard as long as you don’t write libraries” conclusion. Programming is writing libraries, even if you don’t neatly separate them out into their own crate. I do agree with the idea that most articles about Rust, whether they praise or criticize it, lack context that would enable a better conversation though.

                              1. 8

                                “Most loved” is just “% of people that have used it and want to keep using it”, so it’s very explicitly not “people who haven’t used Rust and like what they’ve heard of it”

                                1. 4

                                  I should have been more precise in my choice of words, by “people who haven’t used Rust” I meant “people who haven’t used Rust in any deep, extended of meaningful way”. It’s not rare for people to answer “yes” to the question “have you used X” even if the depth of their experience is limited to using X for a 50-lines program.

                                  As an example, if I was answering the stackoverflow survey I would say that I have used Rust (I wrote an interpreter for an esolang and a Neovim GUI in it, maybe 3000 lines in total?) and that I would like to keep using it, but I also wouldn’t consider my answers about Rust as interesting since my experience with it is very limited.

                                  1. 3

                                    I think you’re projecting a lot of assumptions not in evidence onto a very straightforward survey question.

                                    “It’s a cult because I assume everyone or at least a highly significant percentage of people who said they’d used it and would like to keep using it, have in actuality barely used it. No I don’t have any actual data backing this up, why do you ask?” doesn’t exactly sound like much of anything other than reasoning from sour grapes and solipsism.

                                    1. 2

                                      No I don’t have any actual data backing this up, why do you ask?

                                      The data I am using to infer that Rust hasn’t been used a lot is the amount of Rust job offers available, compared with other programming languages such as C++ or JavaScript. To me this is an indicator that Rust hasn’t been used in a lot of industrial settings yet.

                                      Another datapoint I have is issues like these: https://github.com/neovim/neovim/issues/8669 . These RIIR proposals often come from people who have little to no experience at all with Rust, if you look at their Github profiles.

                                      I’m not saying that nobody uses Rust in anything that matters (Mozilla has been shipping Rust code for 5 years) or that you necessarily end up hating Rust when you actually use it (every mozillian experience report I’ve read is extremely positive). I’m saying that there is a lot of hype around Rust and that the engineers answering the stackoverflow survey probably don’t have as much Rust experience as what we would want in order to consider their experience a useful datapoint.

                                      I think Rust is a huge improvement on the state of the art, and I like it, but denying the hype around it is wrong in my opinion. It set ups people with wrong expectations and will result in disappointments (I’ve seen this happen in a couple of colleagues, who usually are fairly good at ignoring hype).

                                    2. 1

                                      The question used to form the metric was:

                                      Which programming, scripting, and markup languages have you done extensive development work in over the past year, and which do you want to work in over the next year?

                                      50-line programs do not qualify as “extensive” development work.

                                      Also, a personal anecdote: I know several people who write Rust for their day jobs, and they love it.

                                      1. 1

                                        Oh, interesting, this is not how I remembered the question. This means that I was wrong and the stackoverflow survey is a valid datapoint after all.

                                        I know several people who write Rust for their day jobs, and they love it.

                                        I did not deny their existence, I just (wrongly) asserted that they weren’t as many as we thought they were :).

                                  2. 3

                                    I also wouldn’t agree with the “Rust isn’t hard as long as you don’t write libraries” conclusion. Programming is writing libraries, even if you don’t neatly separate them out into their own crate.

                                    Not all libraries are equal. As someone who likes Rust and uses it daily, Rust can be very difficult for making libraries for general consumption, but relatively easy when libraries are made for a smaller audience (i.e. company internal). There a ton of API level decisions that have wide ranging trade-offs and constraints on they place on their consumers, many of which aren’t immediately obvious. The more generic solutions to those constraints become increasingly complex and introduce even more API surface points that could have unintentional affects.

                                    1. 3

                                      Rust can be very difficult for making libraries for general consumption, but relatively easy when libraries are made for a smaller audience (i.e. company internal)

                                      I haven’t yet written nearly enough public-facing Rust to know if this is indeed the case. I haven’t hit that threshold yet. But if it is, I think this is further enforcing @glacambre’s point about hypes (which my internal jury is still torn on FWIW). “Can be difficult for making libraries for general consumption, but relatively easy when libraries are made for a smaller audience because it’s difficult to make constraints” can be quite easily shorted to “is not very good at building generic, reusable models”.

                                      That’s really not a good thing for a programming language to suck at. Libraries for general consumption, especially large ones, are exactly the things I don’t want to make myself. I sort of trust myself to roll out my own ELF header parser or whatever. It’s those damn large libraries like, I dunno, the Qt framework, which I am more than happy to let fifty-people teams of well-paid engineers to handle, especially since it’s unlikely that I’ll be able to churn anything like it in a timeframe of less than a decade or so.

                                      Besides, I really don’t want to write libraries for a small audience! If I’m going to write code that I will release publicly, I want it to help as many people as possible, not just my colleagues. And if it’s code that others wrote, I am the damn audience. The whole point of having a rich set of libraries is for people not to have to roll their own. If every company writes their own company internal libraries for everything, you don’t have a rich set of libraries, you got Common Lisp cca. 2004 all over again.

                                      I swear to God if Rust really sucks at this and I just wasted like a year’s worth of evenings trying to get proficient at it and five years from now I’ll still have to write C++, I am so quitting this stupid programming thing.

                                      1. 5

                                        I don’t think writing Rust libraries is harder due to composition – if anything Rust libraries are easier to compose IMO, because they use composition instead of inheritance you don’t run into a weird situation where, e.g., an object needs to be the child of two different libraries’ parent classes or something like that. You just stick two things in a struct, or implement two traits, or whatever, all’s good.

                                        The thing about Rust that makes libraries more difficult is the number of things you want. For example if you’re implementing a hash table in, say, Python, the API interface probably looks like:

                                        class HashTable:
                                            def get(self, key): ...
                                            def set(self, key, value): ...
                                            def iter(self): ...
                                            # maybe some others
                                        

                                        whereas the equivalent in Rust is at least:

                                        trait HashTable {
                                            fn get(&self, key: K) -> Option<&V>; // regular immutable access
                                            fn get_mut(&mut self, key: K) -> Option<&mut V>; // mutable access for changing the value
                                            fn set(&mut self, key: K, value: V);
                                            fn iter(&self) -> impl Iterator<...>;
                                            fn iter_mut(&mut self) -> impl Iterator<...>;
                                            fn into_iter(self) -> impl Iterator<...>;
                                        }
                                        

                                        and that’s not getting into ZSTs, thinking about object safety for dyn, panic safety, no_std, async, etc… these things force you to think about aspects of your library, like allocation, that other languages don’t.

                                        Because of no_std, a lot of Rust libraries will divide themselves into a part that requires allocations, and a part that doesn’t, so that part of the library can be used without a system allocator. Python, Golang, etc. libraries don’t have to think about that (though C{,++} and Zig do!). Because of object safety, you sometimes need to think about what parts of your traits require a sized return type, and which don’t (and can be annotated Self: ?Sized), if you want to support trait objects. In a lot of languages (even systems languages like C++!), everything is behind a pointer and has a vtable and thinking about that isn’t needed.

                                        That all said, once you make a nice library interface it’s generally a joy to use, and I find libraries in the Rust ecosystem tend to be quite flexible, reusable, and high quality. But there’s a lot of concerns to think about, and Rust libraries do tend to churn their API in pre-1.0 versions while they work towards something that handles all the concerns in a nice way.

                                        1. 2

                                          Yeah, I can’t say I’ve hit a threshold where I found it difficult to write reusable (i.e. library) code past a certain size, or past a certain size of an implied audience – but I’ve not written enough Rust code, either, hence the “yet” in my prior post :-).

                                          I think it’s a given that a model that requires you to explicitly formulate data access constraints (mutable/non-mutable, unique/shared ownership etc.) will result in more verbose code than one which can leverage a GC, like Python’s, but that’s a trade-off that’s always been there. IMHO the higher churn generated by the more diverse API is a trade-off worth making. The C++ API interface for a hash table would be closer to the Python version, but the smaller footprint isn’t free: you pay for it with ever-multiplied head scratching at the user end about whether each function is thread-safe or not. And if you want an implementation that’s as fast as possible in the more favourable cases (e.g. immutable access) without relying on intimate compiler knowledge (which tends to backfire in wider settings) you wind up with a wider API.

                                          Similarly, API churn in pre-1.0 libraries has always been a thing. You rarely get code that can be productively interfaced in practical settings just by copy-pasting functions from a program. Unless you’re doing something that’s well-understood (like a hash table) there’s bound to be some trial and error.

                                          Maybe API churn rate is a little higher in Rust but I think part of that will stabilise in time. Some of it is due to the high language blog/evangelist/fan post churn, a phenomenon we all know and loathe from C++ land, where every new standard version brings out a flurry of “here’s how you should now do ”. That’ll never die out, but as more people develop their own idioms and write more real-world code and fewer toy programs, more of it will be ignored. And, of course, some of it is just because the language is still relatively young and idioms are still being developed. That tends to quiet down in time.

                                  1. 1

                                    In my experience, sdl2 is insufficient for text-editing needs. For example, key presses with modifiers on non-US keyboard layouts will sometimes result in surprising keydown/textinput events. I’m also not very fond of SDL’s non-thread safe model, as it prevents doing things like handling inputs in a thread and managing windows/graphics in another.

                                    1. 4

                                      In most (all?) programming languages specifying a type also implies choosing a particular layout in memory. That’s a pragmatic choice. But they could be separate concerns [1], but that would have an impact on source code readability (at least for as long as source code is plain text).

                                      [1] Check out https://www.janestreet.com/tech-talks/unboxed-types-for-ocaml/ to get an impression how these can be separate concerns.

                                      1. 10

                                        But they could be separate concerns [1], but that would have an impact on source code readability (at least for as long as source code is plain text).

                                        Could you describe this in more details? Ada lets you specify type and representation separately in a fairly readable manner in my opinion:

                                        -- Create a type Small on two bits where -7 is represented as 0b00, -6 as 0b01...
                                        type Small is range -7 .. -4 with Size => 2;
                                        
                                        -- Create a array type of 8 Booleans, packing it into a single byte
                                        type Arr is array (1 .. 8) of Boolean;
                                        pragma Pack (Arr);
                                        
                                        -- Create a struct where the fields span arbitrary ranges of bits
                                        type MyRec is record
                                          A : Boolean;
                                          B : Integer;
                                          C : Integer;
                                        end record;
                                        for MyRec use record
                                           A at 0 range 00 .. 04;
                                           B at 0 range 05 .. 37;
                                           C at 0 range 38 .. 128;
                                        end record;
                                        
                                        1. 5

                                          Wow, that is really elegant. Somehow I missed that Ada could do that. Rust could learn a lot from that level of clarity IMO. Thank you for this example!

                                        2. 3

                                          Rust actually has a bit of flexibility there. Not a huge amount, and less than the compiler actually uses in a practical sense, but some. Notable examples: References to small structures passed to a function may pass the function a pointer, or more likely will just copy the structure into registers and copy it back afterwards. Struct fields do not have any set order, so the compiler will reorder structs to squish out unnecessary padding. There’s not even any promise that two instances of the same struct will have the same representation, as far as I know. And of course, Option<NonNull<T>> may decide to use a null pointer to represent the None variant of the option.

                                          On the other hand, contrast Rust with the very first line of your link: “OCaml has a well-deserved reputation for compiling quickly…” :-P (Also wow that’s an excellent talk.)

                                        1. 10

                                          Why is the databases tag insufficient in your opinion?

                                          1. 1

                                            I find it to be too generic, similar to the programming tag. Looking at the last 2 weeks of stories, 6 out of 13 stories under databases where about sqlite. Giving sqlite its own specific tag might make it easier to find sqlite related posts and could potentially cut the posts in databases to half, making it easier to find non-sqlite related posts for those looking for them.

                                            1. 1

                                              Tags are for filtering out, not for finding stuff.

                                              1. 11

                                                Tags are for both. That’s why you can subscribe to emails for specific tags.

                                                1. 5

                                                  Tags are meant for filtering things out, but they surely can double as a way to filter for something you are interested in. Otherwise, why do we have helpful URLs like https://lobste.rs/t/databases?

                                                  1. 2

                                                    Tags also let you know what a story is about. If a story title is “I built a X” but it’s tagged “go” “sqlite” you know how they built it before you click. Without that, you might not care enough to click.

                                                    1. 1

                                                      The database posts I care about are related to sqlite. With a sqlite tag, I’d filter out databases and just keep sqlite, which fits your described use case. I’d love to see this tag.

                                                1. 2

                                                  Here’s before-and-after pictures of a huge error message overhaul which ReasonML carried out in 2017, as written abbout in their blog post:

                                                  It’s funny, I find the original message easier to read. The “We’ve found a bug for you!” line is unnecessary fluff, the 5 lines of source code are both too much context (a single line makes the problematic statement more obvious) and not enough (I would need to jump to my editor to figure out where data comes from). I don’t know how I feel about the “The incompatible parts” line, I feel it’s slightly redundant but I can’t rule out it being useful for more complex types (but wouldn’t we then be falling into the same “long error messages” trap decried by the paper?). Also, it’s just a matter of taste, but I find the use of We or I by the compiler (or software in general) rather unnerving.

                                                  Currently, most tools print their output to the console or error window as text. However, they could instead output structured output such as JSON, XML […]

                                                  GCC supports -fdiagnostics-format=json. Using this instead of parsing text messages has resulted in a huge quality of life improvement for the people I know who work on IDEs :).

                                                  1. 5

                                                    As an extension developper who works on very stateful extensions (can’t do otherwise due to performance reasons), having to make my extensions’ background process “restartable” is going to be a nightmare.

                                                    I also dread the new permission model, I already audit the code of the extensions I install, I don’t want to have to manually allow them to run on websites every time I install them.

                                                    I can see how these changes are great from an end-user point of view though. I’m just sad that this continues to follow the trend of improving things for “normal” users while “technical users” are left behind. I guess it makes sense though, the pool or normal users is much larger that the pool of technical users and Mozilla wants to grow.

                                                    1. 2

                                                      And yet, it’s continuing to shrink.

                                                      Firefox should realize that there’s no market in being the second best product for the biggest user pool.

                                                      1. 2

                                                        It’s shrinking in relative numbers, but is it shrinking in absolute numbers too?

                                                    1. 4

                                                      Does anyone know what part of the book is about language design? I feel I know enough about compiler construction, but I’d like to read more about language design. So far I feel language design is 100% art and 0% science, but I’d be delighted to discover that I’m wrong.

                                                      1. 5

                                                        I skimmed over a few chapters (e.g. on semantic analysis) and I don’t think it’s about language design, at least not more than any other compiler book.

                                                        I think language design is mostly art but there some things people can agree on (although they’ve probably not been written down):

                                                        • syntax and semantics should correspond, e.g. similar things should look similar; different things should look different
                                                        • familiar syntax does matter, because applications these days are composed of many languages. e.g. you can be a purist and say = means equality, but if == and === mean equality in the 10 other languages I program in, I will be annoyed with your language
                                                        • There’s no substitute for writing tons of programs. Or conversely a language designed by someone who has only written a few programs will almost certainly be bad / limited

                                                        A pretty good paper:

                                                        Seven Deadly Sins of Introductory Language Design https://users.monash.edu/~damian/papers/PDF/SevenDeadlySins.pdf (although I would say there is a bias toward languages for undergrads in academia, for obvious reasons)


                                                        Programming Language Explorations is a good book that may spark thoughts on language design. Chapter 14 has an explicit list of language design questions

                                                        https://www.amazon.com/Programming-Language-Explorations-Ray-Toal/dp/149873846X

                                                        I recommended it 3 years ago: https://old.reddit.com/r/ProgrammingLanguages/comments/d0o85t/nice_book_for_language_designers_programming/

                                                        1. 3

                                                          I feel that there is a lot of math & science available to be applied to language design. I’ve been doing a deep dive into this. I don’t really see much, if any, of this math and science reflected in the textbook’s table of contents.

                                                          It looks to me that this book is stuck in an era where C and Pascal were at the leading edge of programming language design, and where syntax design is the main area where you apply math and science (formal methods) for language design. Eg, creating a BNF grammar for the syntax. I personally feel that syntax design is relatively shallow and trivial, and that the most important areas of language design, where math and formal methods should also be used, are elsewhere.

                                                          I don’t have a book or website that adequately summarizes this. It’s just that I’ve read hundreds of academic papers on programming language design, full of math, and have been working to pull out the parts that are relevant to my design goals. It’s hard to summarize.

                                                        1. 2

                                                          Looking to start a dialog and nothing else really. I’m having doubts about my recent thoughts on software longevity.

                                                          1. 7

                                                            Have you looked into Knuth’s efforts? For TaoCP he defined his own assembly language for this exact reason. TeX was implemented as a literate program in Pascal, which is an easy to implement, very stable target (it was designed to be implemented in a compiler class, after all). He probably is the person whose software has the longest intentional life of anything running today.

                                                            1. 1

                                                              I haven’t but that sounds perfect to check out - thank you!

                                                            2. 1

                                                              FWIW I’ve been enjoying your exploration of ideas around software longevity and hope you keep exploring ideas. You’ve helped push me to take a look at SML and provided an extra dimension of consideration around some half-baked ideas I was chewing on.

                                                              1. 3

                                                                Thank you, it’s motivating to know I’m not alone.

                                                                Just as an aside, the next “step” for me is writing my first real 100 year program; I’m still unsure what it will be. Most likely it’ll be something which replaces what I use frequently, like IRC, email, RSS feed reader, or a basic HTTP client to view and interact with simple web pages like lobste.rs. Thanks to the “simple web” movement the latter is becoming more useful again! My day job though involves full featured web browsers so it won’t sever me completely unfortunately.

                                                                I’ve also had the idea of writing a pidgin-like clone for services I use, so I can get a seamless experience using IRC, Facebook Messenger, Discord, Matrix, etc. I think the best idea is to transform all those messages into ActivityPub messages and then consume them… So essentially a bunch of ActivityPub bridges.

                                                              2. 1

                                                                A data point. One program I wrote back in 1991 I still use to this day. It’s in C, with no dependencies other than a standard C compiler (and the standard C library). It has been modified since then (in 1992, 2009, 2011, 2012, 2015, 2020 and 2021) so I’m unsure what that means in this context. Another program I wrote in 1999 that I still use today is in C (my blogging engine). And just for kicks, I just typed in a C program published in 1985 (but probably written earlier) and it worked as is (but with some warnings).

                                                                Now, am I saying that C should be a 100 year language? Well, it’s half way there. The only other contenders I see are Fortran, LISP, and Cobol (from an “it exists and is still used” perspective).

                                                                1. 2

                                                                  If Cobol counts, then so do Ada, Forth and Basic, all three still used in specific domains. If LISP counts, then so do SQL, APL and Prolog, whose original implementations aren’t used anymore but still live through other incarnations.

                                                                  And I’m sure I’ve forgotten a few others. That makes C a little less impressive I think.

                                                              1. 10

                                                                pine64 needs to do some soul searching. throwing hardware out into the world and “hoping” folks show up to write software (for free) to support it is not sustainable. the difference* between pine64 and the other companies listed in the article is that the other companies hired developers to make the devices functional. on the other hand, the most functional pine64 device I own is a desktop power supply that required writing 0 software/firmware.

                                                                i’m still glad pine64 is around, but my desk drawer can only hold so many more of their products that seemingly have no chance of being useful because of the massive effort required to make them work, and pine64’s lack of interest to do so. they seem perfectly happy just making hardware. good hardware on its own does not a good product make.

                                                                • ok there are many many many differences, but the one that supports my point…
                                                                1. 8

                                                                  It’s often not even good hardware. There are often hardware issues that go unresolved in later revisions. My rockpro64s are gathering dust because the PCIe slot is buggy.

                                                                  I got a pinephone knowing it would only ever be a toy under development. But, even for it the accessories are just bad and I don’t understand why they make some of them. And, the keyboard finally was available after months of talk and it is pretty horrible.

                                                                  I have mixed feelings. I know things like the earbuds will have buyers with a real interest, but I also think they generate a lot of e-waste.

                                                                  1. 2

                                                                    yep. after managing to accrue three different generations of (each unusable in their own, weird ways) PinePhones, and after playing with the PineTime dev kits (which was such a “meh” experience I never bought the production models), and after watching some friends’ issues with the Pinebook{,Pro}, I’ve largely sworn off Pine’s hardware as “you get what you pay for”.

                                                                  2. 1

                                                                    I haven’t bought a single pine64 product because I know I’m not part of their target. Perhaps you’re not part of their target either? It seems they’re doing fine “throwing hardware out into the world and “hoping” folks show up to write software (for free) to support it”.

                                                                    1. 7

                                                                      I’m one of the core developers of postmarketOS. If I’m not the target, then who is?

                                                                      That said, I still use my pinephone and other pine64 devices. My point was that a company who just makes hardware and hopes someone else will make it functional is almost certainly going to generate a lot of e-waste (as someone else pointed out), and that’s not great.

                                                                      1. 2

                                                                        I’m one of the core developers of postmarketOS. If I’m not the target, then who is?

                                                                        People who are fine with a company selling hardware without any software? :)

                                                                        I am not a free-market absolutist but the e-waste problem, in my opinion, comes from people buying the products and then doing nothing with them rather than the company making the product available. Pine64 has been pretty clear from the start about their device not being for people who don’t want to get their hands dirty with software. It’s fairly easy to discover the state of linux on the phone without buying a pinephone (buy a used one, grab postmarketOS or sailfishOS, flash the phone), buying one and then shelving it because “it doesn’t work” is entirely the fault of consumers and not the fault of the company, IMO.

                                                                    1. 80

                                                                      Please take it easy in the comments. Yes, the primary author of the language is famous for posting incendiary, attention-grabbing rants. If you respond to this link with vitriol, even if you’re explaining how you dislike parts of this project’s design, you reward trolling and diminish our community.

                                                                      Remember there are always a few thousand readers to every commenter. If you’re disagreeing with someone, you’re more persuasive to readers when you make your points and let them judge than descend into bickering.

                                                                      1. 33

                                                                        Yes, the primary author of the language is famous for posting incendiary, attention-grabbing rants.

                                                                        Rants which I might note that he apologized for, and is doing a lot less of as well.

                                                                        1. 17

                                                                          Do you have a link to the apology you’re talking about? I’ve steered clear of his projects for a while now because of his toxicity, but if he’s truly making an effort to change that, I may be willing to reconsider.

                                                                          1. 16

                                                                            (Disclaimer: I don’t know Drew personally. I have found several of his public comments abrasive. I also use and like sr.ht quite a bit.)

                                                                            Just because I couldn’t remember when that toxic series of posts went up either, and couldn’t remember when his (apology or at least apology-adjacent) conciliatory comments went up, I used search engines to find the words “fuck” and “asshole” on his site. Those turned up both the earlier vitriolic posts and his statement of his ambitions to no longer make such posts. And they showed that he has largely avoided those two words in the past year, as far as the search engines are concerned, since. Those posts where he did use them don’t direct them pointedly at people, IMO.

                                                                            Sample size is small, obviously, but it looks like the stated determination to be less toxic has been accompanied by progress in that direction.

                                                                            1. 13
                                                                              1. 3

                                                                                Thanks! I wish it was a little more prominent, but I’m glad someone was able to find it.

                                                                              2. 4

                                                                                I went looking for it, and… both the apology, as well as the angry rants which prompted him to apologize, have been deleted from his blog. (Unless I’m misremembering which status update the apology was written in the first place.)

                                                                                1. 7

                                                                                  Thanks for looking! I’m assuming it was his Wayland rant, since I can’t find a link to it from his blog index, but I can confirm the page still exists. I even wrote a pretty large response to it on this site because it was in very poor taste. I’m avoiding linking to it directly because he seems to have taken it down on purpose, and I’m happy to respect his decision.

                                                                                  I appreciate that he’s taking steps in the right direction. I don’t think I’m quite ready to look past his behavior, but I’m still willing to reconsider if he continues in this direction. It’s a very good sign.

                                                                                  Less vitriol in the open source community and software in general is definitely a good thing.

                                                                          1. 2

                                                                            I know that the primary target audience is vision impaired hence the plain text focus of the site, which I applaud. But a large potential audience is made up of people with dislexia. Please include a few screenshots.

                                                                            1. 1

                                                                              The project is extremely WIP and screenshots would be a bit premature.

                                                                              1. 1

                                                                                What kind of screenshots do you expect for a tool that doesn’t have a graphical user interface?

                                                                                1. 3

                                                                                  Screen readers absolutely do have graphical interfaces. They show focus, captions, and graphical configuration menus. Orca is an outlier here.

                                                                                  Screen readers aren’t just used by the totally blind. They’re used by people whose vision is bad enough to render them legally blind too.

                                                                                  In your browser devtools, navigate to vision deficiency emulation. In Firefox, this is under the “Accessibility” pane; in Chromium, it’s under the “Rendering” pane. Select “blurry vision”. The result will make it nearly impossible to read text, but possible to discern page layout. A highlight on the currently focused area will help navigate while using a screen reader.

                                                                                  1. 1

                                                                                    Screen readers absolutely do have graphical interfaces. They show focus, captions, and graphical configuration menus. Orca is an outlier here.

                                                                                    I agree, however Odilia doesn’t have a graphical interface, does it? I’m not seeing any deps on a graphical toolkit here: https://github.com/odilia-app/odilia/blob/main/Cargo.toml .

                                                                                    In your browser devtools, navigate to vision deficiency emulation. In Firefox, this is under the “Accessibility” pane; in Chromium, it’s under the “Rendering” pane. Select “blurry vision”. The result will make it nearly impossible to read text, but possible to discern page layout. A highlight on the currently focused area will help navigate while using a screen reader.

                                                                                    I don’t think a screenshot of this would make sense on Odilia’s presentation page as this is really a browser thing, not an Odilia thing.

                                                                                    1. 1

                                                                                      Odilia is extremely WIP. They only just finished and dropped a PoC prototype to begin working on “the real thing”. As I said in another reply, screenshots would be premature. However, it ought to have one in the future (imo) so the question is still relevant.

                                                                                      The blurred-vision example was something I cited as a rationale for including graphics in a screen reader, not as a rationale for including screenshots.

                                                                                      1. 1

                                                                                        Right, I think we agree then, when Odilia gets a graphical user interface it’ll make sense to take screenshots of it :).

                                                                                  2. 1

                                                                                    I would expect a simple ui with play and pause buttons as well as a speed slider.

                                                                                1. 12

                                                                                  I know it’s not constructive but I really feel a bit weird about emoji in general. Obviously people seem to like them and they’ve gained an immense amount of adoption but I still feel like pictograms that differ based on platform, version and implementation are absolutely cursed for conveying information.

                                                                                  What I mean is: pictures are already lossy at evoking an idea or connotation in the viewer. Pictograms are even more lossy since they are simplified pictures.

                                                                                  So it’s already an extremely lossy medium and depends heavily on context; even if we both have the same model of phone on the same version of an operating system.

                                                                                  When you add uncertainty in the outcome then it only gets worse.

                                                                                  I have also ran afoul of assuming that the race of a particular emoji was an intentional choice intended to convey a particular meaning (I assumed a racist one, actually), when in fact it was just that the person sending it preferred that race of emoji…

                                                                                  1. 9

                                                                                    Miscommunication is already common with words. Language drift happens a lot. Connotations of words change more rapidly than anyone can responsibly keep up to date on. I don’t think Emoji are much worse that in that regard.

                                                                                    In fact, I’ve had better communication with emoji than without. That’s before discussing the artistic merits. Emoji are fun! ❤️

                                                                                    Imagine if I had ended my comment with 😃, 🥺, 😒, 🧐, 👌, or 🖕.

                                                                                    The connotations are ❤️ is attempting to convey positive feelings about emoji and my goodwill towards those reading my comment, whereas 😃 would be more personal enjoyment.

                                                                                    1. 3

                                                                                      In fact, I’ve had better communication with emoji than without. Imagine if I had ended my comment with👌

                                                                                      That would’ve been a really bad idea because, depending on where your interlocutor is from, it means OK, this is worth nothing, you’re an asshole, you’re gay (and not meant in a good way), possibly are you gay because I’m also gay wink wink (this is the only one that I’ve only heard about, but I’ve never seen it used like that), or the same thing that’s meant by 🖕.

                                                                                      FWIW, where I’m from, it means either “this food is good” (it’s understood as “OK” but only when referring to food, due to circumstances that are really complicated to explain – if you tried to use it in any other context it’s quite likely that no one would get it) or, among younger people – again, for reasons that are really hard to explain – it means “let’s smoke together”, and I don’t mean tobacco.

                                                                                      Edit: I don’t mean to say that emojis are bad and they’re a waste of time. They’re cool and I use them all the time and usually, when these things happen, they’re funny. But using them in a professional setting is… probably as bad an idea as back when they were called emoticons. Politics aside it’s really something that can come out wrong for all sorts of reasons, starting with cultural differences and ending with rendering differences.

                                                                                      1. 3

                                                                                        I am actually aware 👌 is obscene in other cultures. 🙂 Gestures (and body language) can vary significantly from place to place. Perhaps I should have mentioned that. I don’t think emoji make things worse or better in that regard.

                                                                                        I do use emoji in professional emails but I stick to a few positive ones that are commonly understood in the US: 😃, 🙂, 😉, and 👍. I use them to convey emotional content that would otherwise be missing.

                                                                                        I see people in my company using 🙏 for gratitude. It confused me at first because I recognized it as “praying”, but once I understood the meaning, it became a nice personal touch because it’s used differently than “thank you”. If someone replied with that, you know what you did was meaningful for them.

                                                                                        1. 4

                                                                                          I think it’s safer to only use words. They’re less ambiguous.

                                                                                          But then, of course, since I’ve been legally blind my whole life, I’m used to missing gestures in in-person conversations.

                                                                                          I see people in my company using 🙏 for gratitude.

                                                                                          On the one hand, thanks to Unicode standardization, screen readers can announce that emoji as “folded hands”. On the other hand, I had no idea what that meant until you explained it. Wouldn’t it be better to simply express gratitude in words?

                                                                                    2. 4

                                                                                      Can you give some examples? I usually find emoji to be crystal clear so I’m very intrigued.

                                                                                      The one exception is Skype’s emoji which are a MESS, eg Face With Monocle is flirty, Pensive is anxious, Weary Cat is excited, etc. Their illustrator is very confused about human emotions.

                                                                                      1. 8

                                                                                        I can give a few.

                                                                                        🥺 :: I interpret as “cute, pleadfull” my girlfriend interprets as “sad”.

                                                                                        😤 :: I interpret as “frustrated”, my girlfriend interprets as angry (a seemingly minor but important difference)

                                                                                        💙💗💜♥️ :: I don’t know the distinction between these.

                                                                                        🤐😶 :: I don’t know the distinction between these.

                                                                                        🚃🚋 as above

                                                                                        💂‍♀️💂💂🏻‍♂️ As above.

                                                                                        If you ask me a question about a co-worker and I write down: 😅😶🥸 in reply.

                                                                                        Am I claiming to know something but not say it, or am I stressed by what you’re saying and want to avoid it?

                                                                                        As for other platforms, I can only speak to my experience talking to people on android, I don’t much feel like breaking out my old android device to show the difference, but the differences are well documented.

                                                                                        There is a paper about this (that I just found: https://ojs.aaai.org/index.php/ICWSM/article/download/14901/14751/18420)

                                                                                        Page 5 of this paper shows the glaring difference between emojis on windows vs other platforms: https://arxiv.org/pdf/1709.04969.pdf

                                                                                        1. 8

                                                                                          😤 :: I interpret as “frustrated”, my girlfriend interprets as angry (a seemingly minor but important difference)

                                                                                          Particularly funny since this emoji was originally named “Face with Look of Triumph”, which doesn’t match either interpretation :)

                                                                                          1. 2

                                                                                            Great examples, thanks. I guess my friend group and I tend to naturally avoid these ambiguous emoji but you’re absolutely right that those are not clear, and that’s without the platform discrepancies.

                                                                                          2. 7

                                                                                            The canonical example is the gun debacle.

                                                                                            1. 6

                                                                                              Emoji feel a bit to me like someone else is choosing my language for me. The gun debacle is an obvious example, but also why is there a hamburger emoji but not a laksa emoji? Why is there not an erect penis emoji? And that’s not even going into the minefield of what something like U+1F45A [ Womens Clothes ] should mean and should be rendered as. Most platforms render that as a pink blouse ffs.

                                                                                              And its not solvable - we’ll have to either keep on adding more and more emoji, or start reusing emoji (look at my enormous eggplant!).

                                                                                              Bah humbug. Give me a smiley face, an alphabet (or equivalent) and a language to use them with.

                                                                                            2. 1

                                                                                              GMails emoji are also awful and unbelievably ugly. Why they don’t use system emoji I’ve no idea…

                                                                                          1. 5

                                                                                            This isn’t even a release announcement, it’s a release announcement announcement. Should this kind of link really be allowed on lobste.rs? It’s pretty light on details, even more so on technical details…

                                                                                            1. 3

                                                                                              And it’s from Feb 4… or is it April 2. Why aren’t we required to use ISO8601 here?

                                                                                              1. 2

                                                                                                Yes, do you find the title misleading? I apologise if I shouldn’t have posted that.

                                                                                                1. 7

                                                                                                  No, I don’t find the title misleading, I find the article very light in terms of content. If more links like this one are submitted to lobste.rs, this would lower lobste.rs’ signal to noise ratio. This is something I would like to avoid, as the signal to noise ratio is the thing I like the most about lobste.rs. But people might disagree with me, this is why I want to start a conversation around the subject :)

                                                                                                  1. 5

                                                                                                    I personally find this post interesting, as I can start looking at what to improve in my configuration for this upcoming release.

                                                                                                    1. 4

                                                                                                      You’d also be able to do that when 0.7 actually gets released and the announcement inevitably ends up being submitted to lobste.rs (as it happened for 0.6, 0.5, 0.4.4…). The actual changelog will contain much more information and details too, so will be much more useful IMO.

                                                                                                  2. 2

                                                                                                    Yeah, I think the actual release will be newsworthy, and it’ll be in two weeks anyway! So excite!

                                                                                                1. 7

                                                                                                  Company: AdaCore

                                                                                                  Company site: https://www.adacore.com

                                                                                                  Position(s): GNU Toolchain Developper, Compiler Engineer, Rust Certification Engineer, Web Designer, DevSecOps developer, QA Release Engineer, Simulink Certification Engineer, IT Assets Project Manager.

                                                                                                  Location: Depends on the position! Some are remote, some are on-site. AdaCore has offices in New York, Paris, Toulouse, Grenobles, Vannes, Bristol, Tallinn and probably a few other places I can’t remember right now.

                                                                                                  Description: AdaCore is the main driving force behind GNAT, the Ada compiler originally based on GCC. We’ve also built a lot of other tools revolving around the Ada ecosystem: IDEs, static analyzers, formal proof tooling… What we build is open source and we make money selling support, trainings, certification etc.

                                                                                                  Tech stack: There’s Ada, of course, but not necessarily so - it’s fine to apply even if you don’t know the language. Depending on the position you might also have to work with C, C++, JavaScript, Ocaml, Python, Rust, Simulink…

                                                                                                  Compensation: Again, depends on the position. AdaCore seems to match the market from what I can tell.

                                                                                                  Contact: Please go through the website :)

                                                                                                  1. 2

                                                                                                    Oh man some of these are tempting. On the one hand, I love making language tools, compilers, and anything with Rust… On the other hand, my limited experience with formal certification stuff is that it’s all bureaucracy…

                                                                                                    1. 4

                                                                                                      Yeah, I think I agree, the Rust certification position is probably more about certification than about Rust itself. Possibly not be a great fit for people who enjoy programmnig more than writing reports. However, the GNU Toolchain Dev and Compiler Engineer positions are mostly about programming and is a great fit for nerds of our kind (I know because I used to occupy the Compiler Engineer position :) ).