home.social

#programminglanguage — Public Fediverse posts

Live and recent posts from across the Fediverse tagged #programminglanguage, aggregated by home.social.

  1. Bonjour 🙂

    Voici un petit comparatif de la programmation d'un bouton qui fait alterner un texte.

    ▶️ Événementiel (JavaScript/DOM, Gtk, Qt...)
    ------------
    label := 'state 1'
    on click:
    label := (if label = 'state2' then 'state1' else 'state2')

    ▶️ Mode immédiat (ImGui, G'MIC...)
    --------------
    setup:
    label := 'state1'
    draw:
    if click:
    label := (if label = 'state2' then 'state1' else 'state2')

    ▶️ FuncSug
    --------
    while true:
    label := 'state1'
    await click
    label := 'state2'
    await click

    #programmingLanguage #eventLoop #GUI

  2. An idea to defeat #GenerativeAI in #FreeSoftware:

    Just use a #ProgrammingLanguage that isn’t popular (e.g. #Haskell or some #Lisp dialect) to write your code, but publish human-readable intermediate form of that code in the public code repositories (e.g. the C programming language). Share the actual source code privately with trusted contributors in non-public branches, and require GPG signatures on actual contributions.

    You could argue that not sharing source code is against the GPL, but the GPL does allow you to share the code as a hard copy printed on paper and sent over snail mail. Or you can just wait until the person asking is an actual human that you can trust not to use the source code for LLM training.

    LLMs are unable to learn unpopular programming languages because they don’t have a sufficient corpus of training data to learn how to code it, so if your receive a contribution in C, thank the contributor but inform them that they will have to rewrite the contribution in your Lisp dialect before you can accept it.

    #Scheme dialects like #Gambit , #Chicken , and #Bigloo would work well for this. So would a #CommonLisp implementation that translates to C such as #ECL . Although keep in mind that the idea is to use a less popular language, so you may have to further obscure these languages a little bit, but not in a way that would be difficult for humans. For example, using a macro system, you could use df instead of define, rename types of things like string? to utf8str?, use generic functions with mulitple dispatch so append will work on strings, lists, vectors, and bytevectors. Small tweaks like this might throw-off an LLM asked to write source code in Lisp.

    #tech #software #LLMs #LLM #FOSS #FLOSS #OpenSource #SchemeLang #R7RS

  3. Hello 🙂,

    FuncSug can be used as a workflow specification language.
    I take the example yawlfoundation.github.io/asset (end of page 68), I translate it into FuncSug and I don't need to make 3 "cancellation sets" with 2 elements.

    #workflow #specification #programmingLanguage

  4. #shownotes for @gamesatwork_biz #podcast e542 with are done while watching #SuperBowlLX & the #Olympics. Publication set for Monday 9 Feb on gamesatwork.biz together with @michaelrowe01 and @andypiper. Find e542 on @Spotify @overcastfm @YouTube and all your favorite podcast feeds! Stories and discussion on #ProgrammingLanguage #localization, #VirtualBoy #hardware & #emulation, #AR & #LaserKeyboard, #LEGO terrestrial & orbital #dwellings and a whole lot more.

  5. Pulling together the #shownotes during #SuperBowlLX & #Olympics in #ChapelHill for Monday’s posting of @gamesatwork_biz episode e542 with @andypiper, @michaelrowe01 and yours truly. Stories and discussion on #ProgrammingLanguage #localization, #VirtualBoy #hardware & #emulation, #AR & #LaserKeyboard, #LEGO terrestrial & orbital #dwellings and a whole lot more. Check out earlier episodes, chock full of #AI #metaverse #AR #VR #gamification and so much more on gamesatwork.biz

  6. Cách tạo ngôn ngữ lập trình - Viết trình thông dịch đơn giản bằng Perk! Hướng dẫn chi tiết từ Reddit [r/programming]. Xem video tại YouTube và tham gia thảo luận. #Lậptrình #Interpreter #Viếtngônngữ #ProgrammingLanguage #DevTips

    reddit.com/r/programming/comme

  7. After thought (thought I didn’t plan to put into it), I don’t think "NULL coalescing" and "NULL chaining" needs to be built in to the #ProgrammingLanguage, and here’s why:

    * If you’re getting just one thing, the getter can take an optional default result value. #Python works like this in `getattr`, `.get`, and things of that nature. Having an operator for this is fine, but it seems obvious you don’t **need** the language to do it for you.
    * If you’re walking down a long uncertain chain, I have two arguments:
    * Knowing the path that leads down into the object to the specific thing you want kinda sounds like an #Encapsulation violation. Why do you know so much about the internals of this object. If this deep property is important, maybe it’s part of the interface of the top-level thing. Maybe this is just bad design.
    * Diving deeply involves lots of possibilities: possible defaults, actual methods of finding the named thing (allow inheritance? Is it an attribute? Is it an element of an array? Etc), did you want to just stop or raise an exception?Does saying what you want really come out to a simple, clean, understandable, one-line, expression?

    Maybe I’m biased because I don’t have these operators in my day-to-day language; and also can’t remember hitting this situation. And I can certainly see such operators could be helpful. I’m not a language designer. But from my actual experience, in this case, the juice just isn’t worth the squeeze.

    #NullCoalescing #NullChaining #LanguageDesign

  8. roto - The strongly-typed, compiled #embedded scripting language for #Rust, used by Rotonda

    Introducing #Roto: A Compiled Scripting Language for Rust (May 2025):
    blog.nlnetlabs.nl/introducing-

    Repo:
    github.com/NLnetLabs/roto

    This looks awesome! I love strongly typed scripting languages! :awesome:

    And the fact that it integrates with Rust so seamlessly... ✨

    #RustLang #ProgrammingLanguage #Scripting #ScriptingLanguage

  9. The official steering committee of the Scheme programming language is calling a vote to replace themselves

    Quoting the memo:

    The outgoing Steering Committee was elected in 2009 and successfully oversaw the production and ratification of the R7RS small language report until 2013. Unfortunately, during the protracted initial development of the R7RS large language after that, it fell dormant.

    The current Scheme Working Group resolved in September 2025 to ask the Steering Commitee for a new election because it felt that after such long dormancy the outgoing Steering Committee was no longer able, as a group, to make and implement decisions effectively.

    The Scheme standardization process charter says, ‘The Steering Committee itself shall establish procedures for replacing its members.’ The outgoing Steering Committee unanimously decided to delegate this task to the current Working Group. The Working Group has very closely modelled the procedure to be used this time on the procedure used last time.

    The Working Group has written a statement to candidates and voters explaining what it hopes for in a new steering committee.

    Lobste.rs thread

    #tech #software #Scheme #SchemeLang #ProgrammingLanguage #R7RS #R7RSLarge #Lisp #FunctionalProgramming #Guile #GuileScheme #ChezScheme #ChickenScheme #GambitScheme #RacketLang #Racket

  10. added debug (DWARF) information to my programming language, XLS. now XLS programs can be debugged with abilities such as breaking at line numbers, and viewing information about local variables and function signatures.

    visibility hashtags: #XLS #ProgrammingLanguage #Debugging #DWARF

  11. i designed a logo for my programming language, XLS.

    visibility octothorpe-prefixed tags: #XLS #ProgrammingLanguage

  12. In #Rust we trust :)
    Polubiłem ten #językprogramowania od pierwszych zabaw z przekazywaniem parametrów do funkcji ;)
    Okazuje się, że zaczynają go lubić również w #Mcrosoft (elementy jądra systemu mają nieco "zardzewieć" – ale o tym czytałem gdzie indziej.)

    arstechnica.com/information-te

    Jak ktoś chce zajrzeć do środka:
    github.com/memorysafety/sudo-r

    #programming #programminglanguage #operatingsystem #security #sudo #su #systemoperacyjny #bezpieczeństo

  13. added token lists to macro language in my programming language XLS, which is called XLiSp.

    now, XLiSp expressions may emit tokens directly, which makes it powerful enough to be a decent macro system. however, XLiSp has a lot further to go.

    one can use XLiSp to generate Ο(1) algorithms for FizzBuzz, as demonstrated: github.com/TheDarkBomber/XLS/b

    hashtags for visibility: #XLS #ProgrammingLanguage #LISP #Macro #FizzBuzz

    oh cool i have some characters left over wheeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee

  14. CW: ‌end of rant; some hashtags for visibility

    now for visibility i need hashtags, so if the reader'd forgive me: #a11y #accessibility #ProgrammingLanguage #XLS #Zig #ziglang #Nim #Elm #Makefile

  15. i have added ranged pointers to XLS (except for the boundary checking features, which i'll add later)

    ranged pointers are like pointers but they store an additional value, the range of a pointer. essentially this range value acts as the count of the number of elements in an array that a pointer interfaces to.

    even without boundary checking, storing this information is a very useful convenience.

    (visibility: #XLS #LLVM #ProgrammingLanguage #Pointers #RangedPointers)

  16. i have added a new example to the #XLS examples directory. this example demonstrates an implementation of GOSUB using anonymous label pointers.

    note well: GOSUB and RETURN would normally be macros, but the XLS preprocessor does not yet support macros, so i have manually preprocessed them.

    on this note, i recommend viewing the Bisqwit video about GOSUB, which i have linked below.

    youtu.be/_vbMJ3-LuFk

    github.com/TheDarkBomber/XLS/t

    #ProgrammingLanguage #LLVM #LabelPointers #GOSUB

  17. added two new features to #XLS today, one common one, the other one not being so common.

    the common one is just return. well, early return, as all functions return their last expression by default. nothing too interesting there.

    the less common one is label pointers. these are like function pointers, but point to a label instead. it's hard to explain what they're useful for, but they do have their use cases.

    mastodon hashtags: #ProgrammingLanguage #LLVM #LabelPointers

  18. added `break` and `continue` constructs to #XLS.

    you can use them to either break out of loops, or continue the loop by going back to the start.

    you can break/continue out of nested loops too, `break` is equivalent to `break 0`, meaning `break out of 0 extra loops`. to break out of the immediate outer loop, `break 1`, and so on. same goes for `continue`.

    currently XLS only has while/dowhile loops, but other control flow structures are planned.

    mastodon hashtags: #ProgrammingLanguage #LLVM

  19. some progress on #XLS: added function pointers (useful thing that crosses variables and functions together), and typedef alias to alias types to other types, it uses Intel® syntax, so `typedef alias char byte` to make `char` an alias for `byte`
    mastodon hashtags: #ProgrammingLanguage #LLVM

  20. Since #java8, the #java #programmingLanguage sports an Optional data type, which can be empty, or house another data type's value. So if a sub process fails due to some error, it can return an empty value. And the calling process can handle that gracefully, without having to make the odd jumps in logic flow that try-catch blocks force.

    But many 3rd-party libs have yet to embrace that. They prefer throwing an exception instead.

    So I wind up wrapping that. Which is annoying.

  21. And the same occurs with any value remembered beyond a very short lifetime, and sometimes even then. (Looking at you, #multithreading.)
    Because a file system is #mutable, our #software #application suffers the effects of the change. And if the #programmingLanguage allows for mutability, like #Java does, then it too suffers the effect of change on remembered values. Especially when we, the programmers, can't see that values were remembered. Which is what #memoization does.