The 64 poems closest in meaning to this word, arranged to spread the colours (progress bar shows chronological position)
-> file: fediverse/3482 ══════════════════════════════════════════════════────────────────────────────────── ┌───────────────────────┐ │ CW: cursing-mentioned │ └───────────────────────┘ "Alright I'm not great with syntax so I'm going to write it in pseudocode first, and then if you'd like I can show you how I work through implementing the syntax. But first - do you want a robust solution, a quick solution, or a rapidly deployed and cheap solution?" using this trick you can pretend to be competent in any programming language, except maybe ancient ones like Fortran or strange ones like lisps or Haskell if they ask you to use a framework or something tho you're kinda boned because you need to know which functions to call and how to initialize context and such. When using a framework, the boilerplate is the code, which is why frameworks suck "*don't call yourself a programmer*" fuck off ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘ -> file: fediverse/2922 ═════════════════════════════════════════════════─────────────────────────────────── @user-192 now I want to re-implement strings as structs in C! I don't know why I never thought of them that way. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘ -> file: fediverse/3700 ═══════════════════════════════════════════════════───────────────────────────────── There is almost zero reason to have a messaging client (like Discord) that is anything more than a wrapper over IRC. There is almost zero reason to have a social media site that is anything more than a wrapper over HTML pages. There is almost zero reason to have forums that is anything more than a wrapper over email. and yet, we build things. and yet, we construct. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════════────────────────────┴───────────┘ -> file: fediverse/4119 ═════════════════════════════════════════════════════─────────────────────────────── what if you wanted to build a project from source but god said`CMake Error at CMakeLists.txt: By not providing a "foo.cmake" in CMAKE_MODULE_PATH this project has asked CMake to find a package configuration file provided by "bar", but CMake did not find one. ` ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════════════════──────────────────┴───────────┘ -> file: fediverse/307 ═══════════════════════════════════════───────────────────────────────────────────── normalize building a library that's just a wrapper around solutions you've made to common problems from the past that can be imported into every project you work on ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════────────────────────────────────┴───────────┘ -> file: fediverse/3154 ═════════════════════════════════════════════════─────────────────────────────────── ┌───────────────────────────┐ │ CW: re: cursing-mentioned │ └───────────────────────────┘ @user-1461 yes... I like tree shapes, you have to address them differently. Lots of pointers, in my experience, which can be kinda fun. I also like large heaps / soups of data that points to one-another. Structs thrown in a pile with pointers to each other. It's great! So long as those pointers can also point back, and you can properly trace how data flows through the system... That's the hard part, I think. trees though... You can start by just saving a "next / previous" with one or both being arrays of pointers to the next or previous entries. Note: plural, entries. That's the fun part - non-linear trees teehee ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘ -> file: fediverse/3028 ═════════════════════════════════════════════════─────────────────────────────────── @user-570 I can write C in Rust, but I can't write Rust in any other language. there's a lot of unique semantic options for accomplishing things that I already know how to do that I often find my syntax is pretty... basic. lots of manual assignments, no more than 4 or 5 levels of function nesting. I like to use threads and arrays, and think about in-game simulation more like a calculation than an input-reacting device. though input would certainly be encouraged to make the simulation more precise. the borrow checker gets in my way, but that's not too big of a problem - I just have to copy a bit more data around. Easy peasy. (I'm a bit rusty, but I can learn syntax) ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘ -> file: fediverse/5189 ════════════════════════════════════════════════════════════──────────────────────── computer programming essentially boils down to putting the right values into the right datastructures at the right time and in the right order. If you count a function call as a datastructure, which I do, because I have opinions. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════════════════════════════════════───────────┴───────────┘ -> file: fediverse/775 ═════════════════════════════════════════─────────────────────────────────────────── @user-192 It's totally simple! It's just structs, void pointers, function pointers, arrays, mallocs, and oh boy I think I see what you mean ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘ -> file: fediverse/6251 ╔═══════════════════════════════════════════════════════════════════───────────────┐ ║ "Hi computer, all is well. Can you create me a visualization of this particular │ ║ mathematical concept? It should be written in Lua using the Love2D engine │ ║ because that's my favorite. I should be able to step through the calculation │ ║ steps and modify values at each stage, and by the end we should have a fully │ ║ interactable system which works through the general concepts of this particular │ ║ kind of math." │ ║ │ ║ "no no I don't want you to explain it to me, I want a tool - a toy - that I can │ ║ play with to better understand it. Let's build it in Lua using the Love2D │ ║ engine because that's my favorite. When we're done we can start converting it │ ║ to use HTML5 - no javascript! - but for now let's get the system operational. │ ║ It should have a config file that can be adjusted with every value we can think │ ║ of." │ ║ │ ║ "can you go through this fully functional system and extract as many values as │ ║ you can think of into a config file? make sure there's efficient loading of │ ║ those values in the main function (or somewhere similar) as well. ty" │ ╠═════════╗ ┌───────────┤ ║ similar ║ chronological │ different │ ╚═════════╩════════════════════════════════════════════════════════────┴───────────┘ -> file: fediverse/2879 ═════════════════════════════════════════════════─────────────────────────────────── ┌────────────────────────┐ │ CW: re: tech info-dump │ └────────────────────────┘ @user-1370 I love this a lot! I want to put function pointers in a "matrix architecture array" and make them point to different functions at different points in the program. I bet you could even point them at each other, so like if M and Y then point at N, A, Y or something. this is really cool I like stuff like this tomorrow I'll take pictures of something similar I'm working on! I abandoned it tho hehe anyway remind me if I forget!! ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘ -> file: fediverse/777 ═════════════════════════════════════════─────────────────────────────────────────── @user-192 Those are good points. The C in our hearts is elegant, but the C that runs on every computer in the world is spaghetti. I'm sure someone's made a language that's "C but simple" - Zig maybe? I looked into V a while back but got turned off of both of them because neither had support for multithreading, which is essential in the modern era. Also, typedefs for structs make me mad -.- ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘ -> file: notes/most-important-machinist-skill ═════════════════════════════════════════════════════════════════════════════════─── probably pole-turning. but second to that, is how to wield sheet metal how to bend it stamp it construct uniform parts factory-ize build predictability in doing so, you enable greater constructions doing it your way you can do it to task but tasks are everywhere sometimes, it's better to automate some of the tasks away ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════════════════════════════╧═════════──┘ -> file: fediverse/633 ═════════════════════════════════════════─────────────────────────────────────────── @user-192 the neat thing about BASH is that it's the glue that holds all your other code together. Write libraries in C and call them with BASH - accomplish broader tasks that are easier to co-create. That's why I like it - it's not the most important, but it's quite beneficial I think _^ ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘ -> file: fediverse/404 ════════════════════════════════════════──────────────────────────────────────────── a preprocessor directive that tells the compiler to ignore all warnings on the next line ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘ -> file: notes/magics-are-rare ════════════════════════════════════════════════════════════════════════════════──── magician only work magic when forced to. This is because magic is rare. It's difficult to create, but if mastered, can have infinity to share.\ \ to solve all of entropy and scarcity, find a way to use infinity. if you can draw from forever, if you can wield all of ever, if then you can make as much as you can grasp. immortality tells me there's just a bit more of ever, and I trust myself to know infinite things. whenever I reach for more, there are more things to know. I am very good at abstraction, says soramech, because I can always know connections between types of sets. recursively and ever choosing to be choosing, [stack overflow] ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════════════════════════════╧════════───┘ -> file: messages/1247 ═════════════════════════════════════════════════════════════════════════─────────── you can even design it as you go, making it do slightly adjacent uses in addition to what it currently does. for example: https://github.com/gabrilend/r-mail is a reference implementation with some ideas for how to design some specific parts. make sure you go through it yourself though, so you understand how it works. don't worry, the source-code files are numbered like the table of contents [chamber of commerce] in a story or book. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════════════════════════════╧═──────────┘ -> file: fediverse/603 ═════════════════════════════════════════─────────────────────────────────────────── @user-447 @user-192 I see, interesting. I'll look into those tables - I've been using C lately and I've noticed myself rebuilding several Object Oriented features. It feels a little silly every time I notice myself doing it, like "oh, I can't separate future paradigms from my practice" ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘ -> file: fediverse/5492 ═══════════════════════════════════════════════════════════════───────────────────── @user-1844 when words are inscribed on a viewable form ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════════════════════────────┴───────────┘ -> file: fediverse/3544 ══════════════════════════════════════════════════────────────────────────────────── ┌───────────────────────────┐ │ CW: programming-mentioned │ └───────────────────────────┘ "I wish there was a language that was as simple as C but had [insert complex language feature here]" ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘ -> file: fediverse/701 ═════════════════════════════════════════─────────────────────────────────────────── ┌──────────────────────┐ │ CW: computer-code │ └──────────────────────┘ totally useless unless you're, I dunno, building a bytecode interpreter or something https://craftinginterpreters.com/contents.html
┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘ -> file: fediverse/1521 ════════════════════════════════════════════──────────────────────────────────────── if we had better installer software we could have programs that work on any different type of machinery. ... isn't that what a compiler is? ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════════════════════───────────────────────────┴───────────┘ -> file: fediverse/5070 ════════════════════════════════════════════════════════════──────────────────────── main() is where you put stuff before you abstract it into a function. Usually it gets quite long, but it's mostly just a table-of-contents listing of all the other functions that are run in order to do this-or-that-or-the-other. -- I wonder if you could generate RNG by hooking up a camera to a lava-lamp and scanning through the pixels or whatever ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════════════════════════════════════───────────┴───────────┘ -> file: fediverse/6310 ═════════════════════════════════════════════════════════════════════─────────────── ┌──────────────────────┐ │ CW: AI-mentioned │ └──────────────────────┘ large language model that generates images by creating SVGs (written in text) and justifying each configurable property of the object with evidence gathered from computational intermediate steps from the other objects. Like "this line should be left of the whatever in order to support the weight of thing which is above and supported by A, B, and C" or whatever. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════════════════════════════════──┴───────────┘ -> file: fediverse/4689 ════════════════════════════════════════════════════════──────────────────────────── pronouns are part of a name they are a component of the whole indispensable for the complete concept ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════════════════════════════════───────────────┴───────────┘ -> file: fediverse/9 ══════════════════════════════────────────────────────────────────────────────────── @user-8 I love theory too! So far software engineering has been mostly UI and databases and such and like... I'm not into HTML, thank you very much. Gimme a Rust project or something and I'll excel ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═══════════════════─────────────────────────────────────────┴───────────┘ -> file: fediverse/5180 ╔═══════════════════════════════════════════════════════════───────────────────────┐ ║ it's trivial to run a C compiler inside of a lua interpretation of a script. │ ║ And vice versa - you could totally run lua functions from C. Just point to the │ ║ spot in memory where they're stored / operating, and call │ ║ "update_class_exhibitor_type_d()" and the linker will come along and say "huh │ ║ this looks like something from this library that's part of the requirements up │ ║ above" (the "includes" section is where you say which files include the │ ║ functions you're going to be calling) and in this particular case it would see │ ║ that you need to start up a lua interpreter *inside of the [either compiler or │ ║ running program I can't remember]* to properly execute the function of the │ ║ function that you're pointing at with a lua-pointer style data object which is │ ║ part of a struct that stores all the other lua functions in a spot in memory. │ ║ │ ║ this would enable you to write computer programs in whatever language you │ ║ choose, and build them into one large project. Essentially opening up software │ ║ development to ANYONE WHO CAN PROGRAM │ ╠═════════╗ ┌───────────┤ ║ similar ║ chronological │ different │ ╚═════════╩════════════════════════════════════════════════────────────┴───────────┘ -> file: fediverse/1229 ═══════════════════════════════════════════───────────────────────────────────────── @user-883 graphics isn't too bad in C if you use Raylib. Here's my template project: If you ever want to do something with a GUI or a game or something then I definitely recommend that library. It's soooooo nice as a C programmer
┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════────────────────────────────┴───────────┘ -> file: fediverse/345 ════════════════════════════════════════──────────────────────────────────────────── If you want to write object oriented C, just make one file per class and use static functions for private methods. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘ -> file: fediverse/4096 ╔═══════════════════════════════════════════════════───────────────────────────────┐ ║ ┌────────────────────────┐ │ ║ │ CW: opinionated-design │ │ ║ └────────────────────────┘ │ ║ │ ║ │ ║ Steps to make a game waterfall style: │ ║ │ ║ Lay out all the data structures and arrange them in containers like arrays or │ ║ hashmaps │ ║ │ ║ Build methods which manipulate those structures (think getters and setters) │ ║ │ ║ Then build machinery which operates upon those structures using those methods, │ ║ like game loops, cooldown timers, status effects, and thread pools. │ ║ │ ║ Then develop a way to present it to the player using UIs, visuals and graphics, │ ║ narratives, sound, etc. This will probably involve implementing your game in an │ ║ engine like Godot, Raylib, or Bevy. │ ║ │ ║ By developing your game in this order, you will DESIGN the systems first, and │ ║ IMPLEMENT them second. Systems are agnostic - implementation is tied to a │ ║ specific engine. You will learn more about programming by doing it this way, │ ║ instead of losing your motivation by learning new tools like game engines or 3D │ ║ modeling systems, which aren't useful unless you already have a game. │ ║ │ ║ I'd recommend starting with pencil and paper until you're ready to implement. │ ╠═════════╗ ┌───────────┤ ║ similar ║ chronological │ different │ ╚═════════╩════════════════════════════════════════────────────────────┴───────────┘ -> file: fediverse/5405 ══════════════════════════════════════════════════════════════────────────────────── can't stop thinking about a visual programming editor that can be interacted with in the same way that people are used to (think chromebooks dragging and dropping icons in a web UI) but produces a text-file full of code and all the required compilation scripts for any language the user requires... seriously, programming is not THAT different between the different languages. especially the main ones. they're all essentially variables and function calls at the end of the day, so why not abstract away all the extra details and build something that n00bz can actually use to build things. I technically could make this but I don't have the bandwidth and I don't think it's important really? who can say, the tools tend to co-create the solutions in my experience. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═══════════════════════════════════════════════════─────────┴───────────┘ -> file: notes/jane-the-keyboarder ══════════════════════════════════════════════════════════════════────────────────── "okay let's see, we need a new CREATURE and let's name it TERRY and let's give it a title: .TITLE = "The Acrobat" " "cool, let me just go show my friends." "hello friends, I have created a creature. It's name is Terrance." wow yeah cool so anyway "hm. let's see if we make him slightly more interesting..." "okay now I've defined him as capable of monotony, maybe they'll see his strife and relate" TERRY.STRIVE += TERRY.REPETITION * global.misery / slaughter_count_victims TERRY.STRIFE += global.war_percentage + ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═══════════════════════════════════════════════════════─────┴───────────┘ -> file: notes/programming-style ═══════════════════════════════════════════════════════════════════════───────────── my programming is not a product., it is a way of thinking. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════════════════════════════┴───────────┘ -> file: fediverse/5338 ══════════════════════════════════════════════════════════════────────────────────── I asked my girlfriend what was so special about lisp she said it was "homoiconic" I asked what that meant she said that the text that comprised the source code was always a valid data structure in the language, meaning you could do strange things like develop new control flow systems or change the behavior of language primitives like + or - I asked what was the point, she said I didn't get it so then she asked me to implement a new control flow operator in my favorite language, Lua, and I was like "bet" so I did and it turns out that in order to do so I essentially created a mini embedded lisp inside of Lua (it was a function that took in two arguments and an operator and she's like congrats that's just lisp) it was at this moment that I was enlightened the beauty of lisp it's true and ultimate purpose is to write lisp code ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═══════════════════════════════════════════════════─────────┴───────────┘ -> file: messages/371 ══════════════════════════════════════════════────────────────────────────────────── take your bash script and update it to possess new functionality, like the ability to re-order your posts and display them on a viewer - or the ability to draw connections between them, showing them in context with one another. Then, use that as display to the user, through the LLM interface. (do it locally, it's only for long-term explanations.) (the user needs to be able to ask questions to the machine, and the machine needs up-to-date information. So give it the ability to make "compound phrases" like "the water temperature is at " or " degrees. This is a [good/bad] thing because " and such, and then string them together using typical ranges of past numerical datas as reference. Like, if something is normally between 100 and 5000 then suddenly it's at 14 or some other threshold (make sure nothing goes below 0, measuring inertia and impact density and other factors) - but identify the connections between each factor, so that you understand which ones are correlating to which effects on the others. Measure things in terms of proximity, and suddenly 3d graphs become a lot easier. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═══════════════════════════════════─────────────────────────┴───────────┘ -> file: fediverse/2003 ════════════════════════════════════════════════──────────────────────────────────── The most important programming language to master is pseudocode. With a firm grasp of pseudocode in your toolbox, you can solve any problem in any language. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘ -> file: fediverse/1948 ════════════════════════════════════════════════──────────────────────────────────── @user-217 lightsaber construction ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘ -> file: fediverse/6348 ═════════════════════════════════════════════════════════════════════─────────────── here's a neat function
┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════════════════════════════════──┴───────────┘ -> file: fediverse/4845 ═════════════════════════════════════════════════════════─────────────────────────── put the variable type at the front of the variable and 90% of your type errors will dissapear like...`int int_main(){ return 0; } ` or`int int_modulation_gauge_percentage_point_plus_or_minus_engagement = 0; ` seeeee if the "int" value is at the start of the name then you can do this too:`double double_modulation_gauge_percentage_point_plus_or_minus_engagement = 0.0; ` then when you go to fill in an "int" value you know to use the one that has the "int" value at the beginning (doh) (do you really think they haven't tried that already? it... sorta worked. people started doing things like "int int_a; int int_b; int int_c;" and such and that got confusing pretty quick because the letters weren't at the start of the word. So for some situations we would mirror them like so: "int A = int_a; int B = int_b; int C = int_c;" and then just use the capitalized letters. ... just don't forget to update the original teehee (this is why we invented shadowed variables) wait, no I meant pointers !!~! -.- ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════════════════════──────────────┴───────────┘ -> file: fediverse/3034 ═════════════════════════════════════════════════─────────────────────────────────── @user-570 I've messed around with Bevy and the library most similar in C is Raylib. in Lua it'd be Love2D I think. I love the idea of those systems. I haven't built a full game using them but I can conceptualize operations within them easier using a framework like that versus a game engine like Godot. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘ -> file: fediverse/315 ═══════════════════════════════════════───────────────────────────────────────────── normalize building games with a built-in virtual machine that plays all previous versions of the game for free ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════────────────────────────────────┴───────────┘ -> file: notes/portfolio ════════════════════════════──────────────────────────────────────────────────────── game design: spiral dominions symbeline gdd Joust War (bytecode VM) grid based warcraft map with random terrain and custom AI Progress [Title of Game] I appreciate Rust, I can understand Rust, but I can't write Rust. Python just kinda... works. It doesn't have a lot of the type checking that other languages have, so it requires some vigilance and diligence. But that's alright, you just gotta work on it. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════───────────────────────────────────────────┴───────────┘ -> file: notes/anarchist-programs ════════════════════════════════════════════════════════════════════════════════──── I'm writing anarchist computer programs. See: ceramic everysoft my game server projects similar-differernt (doomscroll) chronological (tldr) golems project (unstarted) sorenthal-ds probably others... none come to mind... ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════════════════════════════╧════════───┘ -> file: fediverse/6413 ══════════════════════════════════════════════════════════════════════────────────── to understand something, work backward from present understandings back to the fundamentals of algebra. insert words. wield LLM. build a neuronal structure many layers wide. let them coprocess bit-by-bit as they are adding new processors to be "learning" new domain specific memory context-processing-thingy. "over here's the memory cells, over here are the conceptual structure" suddenly, organified. not ideal. much better, I feel, is for a disambiguous association of processor selves, each contextualizing a cache in a ram. ['s horn] ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═══════════════════════════════════════════════════════════─┴───────────┘ -> file: fediverse/1966 ════════════════════════════════════════════════──────────────────────────────────── The design is simple: Have an array of function pointers that need to be assigned to a thread. Then, have a manager thread read through that array, and for every non-zero value put it into a thread-specific array. Those threads will read through their personal array and execute whichever function is pointed to by the function pointer placed in their todo-list by the manager function. ... I'm too stupid to make it happen though. Writing code is hard.
┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘ -> file: fediverse/5250 ╔════════════════════════════════════════════════════════════──────────────────────┐ ║ ┌──────────────────────┐ │ ║ │ CW: AH │ │ ║ └──────────────────────┘ │ ║ │ ║ │ ║ the government is the platform the [companies/countries] do stand upon. they │ ║ owe all to their platform. it is vital for their existence. therefore any │ ║ orthogonally created [unit/union] or organization would work to maintain it │ ║ too. we [can't/can] solve communism, which is the best system for the future │ ║ because everyone gets whatever they want. we just... built enough factories. │ ║ and then, since our culture burned out in a FLASHBANG, unfortunately the rest │ ║ of it was lost. │ ║ │ ║ that future *totally* sucked. but good news is we preserved what we had of the │ ║ present, and here let's just revive them in some distant and far-off day. │ ║ │ ║ *"transgender artifacts" future can suck my ass* │ ║ │ ║ wow weird way to say they're terrible │ ║ │ ║ but they still happen from time-to-time. │ ║ │ ║ cataclysms, vanishings, mass-die-offs and cataclysmic reprisals, all throughout │ ║ time up to the athropocene. │ ║ │ ║ *whoa neat new angle, sure hope it doesn't lead the conversation off of the │ ║ present...* │ ║ │ ║ "disappears into the horizon as one travels towards the sunset" │ ╠═════════╗ ┌───────────┤ ║ similar ║ chronological │ different │ ╚═════════╩═════════════════════════════════════════════════───────────┴───────────┘ -> file: fediverse/2484 ╔═══════════════════════════════════════════════───────────────────────────────────┐ ║ @user-1271 │ ║ │ ║ I can help with that. │ ║ │ ║ I recommend looking at Ollama, which runs an HTTP server on your local machine │ ║ (hope you have a decent graphics card) │ ║ │ ║ then, script some behavior you'd like to implement using Lua and the LuaSockets │ ║ library. Also dkjson to handle the json parts. │ ║ │ ║ then, all you have to do is construct a prompt based on the variables and │ ║ desired input/output and push it into a json packet and send it to the HTTP │ ║ server. It's less complicated than it sounds. │ ║ │ ║ what you want it to do and your implementation for it is the hard part. But │ ║ perhaps this project of mine will get you started: │ ║ │ ║ (I can copy-paste it too if you'd like) │ ║ │ ║ just... don't make a chatbot. chatbots are useless to work on because there's │ ║ already so many of them. │ ║ │ ║ much better I think to use the LLM to process arbitrary information with an │ ║ unpredictable form into more predictable patterns which can be utilized │ ║ programmatically. │ ║ │ ║ Feel free to ask any questions. Do keep in mind that training LLMs is │ ║ unethical, but using them is whatever. │
╠═════════╗ ┌───────────┤ ║ similar ║ chronological │ different │ ╚═════════╩════════════════════════════════════────────────────────────┴───────────┘ -> file: fediverse/6 ══════════════════════════════────────────────────────────────────────────────────── ┌──────────────────────┐ │ CW: Math │ └──────────────────────┘ @user-5 create an array of length 7 initialized to zero. then use a for loop that loops 97 times and adds a random number between 1 and 20 to an array index that iterates through the array each time through the for loop. NOTE: be sure to also change the loop counter based on the random number too, so you allocate exactly 97 points no matter what random number you get. Oh and speaking of which if the loop counter ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═══════════════════─────────────────────────────────────────┴───────────┘ -> file: fediverse/729 ╔════════════════════════════════════════──────────────────────────────────────────┐ ║ @user-552 @user-553 │ ║ │ ║ sounds like something we should dedicate valuable resources to solving. After │ ║ all, no structure or entity would want to possess weaknesses (such a │ ║ misapplication of purpose and direction) or other such errors in their design. │ ║ │ ║ Like, I bet we could test that and find out. │ ║ │ ║ and if, for example, we find that we no longer possess the capacity for │ ║ learning... │ ║ │ ║ well, then maybe that's something we should work on. │ ║ │ ║ because learning new things... that's just an application of development │ ║ resources towards broadening our horizons. │ ║ │ ║ do we really need to solve pi to ten bazillion digits? I mean yeah it's cool │ ║ and all but most of the interesting stuff happens around zero. │ ║ │ ║ you can always learn to learn, that's one of the neat things about it. It's │ ║ self-bootstrapping. As long as you have the capacity to *apply* yourself toward │ ║ a pictured goal, well... then you can learn. And no human or other sentient and │ ║ capable being would lack such an ability, because it's intrinsic to our form. │ ║ │ ║ therefore, learn │ ╠═════════╗ ┌───────────┤ ║ similar ║ chronological │ different │ ╚═════════╩═════════════════════════════───────────────────────────────┴───────────┘ -> file: fediverse/5990 ═══════════════════════════════════════════════════════════════════───────────────── I have this local language model framework but it's not built into anything more than a single-response question. It's runnable as a bash script or lua require, which is easy enough. Alas, if only I didn't have to use evil corporate infrastructure to make evil corporate cursed artifacts [hey don't blame this on us] oh I'm not, I'm just saying that it'd be cooler if I could build my own tools. Alas, I'm... lasy? n...no I'm drawn to the power of it it's got a different magnitude it's hard for me to apply myself for things that last longer than a "get stoned", but I try as if every time afterwards I might die. well, more distraction time, as I wander through claude code ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════════════════════════────┴───────────┘ -> file: fediverse/614 ═════════════════════════════════════════─────────────────────────────────────────── What does your template for a new project look like? Here's mine:
┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════──────────────────────────────┴───────────┘ -> file: fediverse/4611 ╔══════════════════════════════════════════════════════────────────────────────────┐ ║ *to begin with, there is either something, or nothing. And there is clearly │ ║ something, because if there was nothing, then this would not exist. the │ ║ existence of "something" is self-apparent because something is observing this │ ║ thing, which is not nothing.* │ ║ │ ║ *since there is something, we must then decide if there is just one thing, or │ ║ if there are more than one things. Since we can tell that the thing-or-things │ ║ that exist are textured, varied in their composition, then we can surmise that │ ║ they are composed of differing parts. After all, if the thing-or-things that │ ║ existed were atomic, they would be homogenous on all sides. And since this │ ║ thing-which-is-being-observed is not the same at the beginning as it is at the │ ║ end, it can be assumed that there are more than one things in existence, hence │ ║ things.* │ ║ │ ║ *If there are more than one thing, then they can be counted, as many as they │ ║ exist. One thing here, one thing there, on and on. We can add groupings to │ ║ these things, here's one group over here, here's another...* │ ╠═════════╗ ┌───────────┤ ║ similar ║ chronological │ different │ ╚═════════╩═══════════════════════════════════════════─────────────────┴───────────┘ -> file: fediverse/5633 ═══════════════════════════════════════════════════════════════───────────────────── I wish someone would make a "meta game engine" that would run any type of project that you gave it. Unity, Unreal, RPGgame-maker-studio, Godot, etc ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════════════════════────────┴───────────┘ -> file: notes/sora ════════════════════════════════════════════════════════════════════════════──────── do it once in english, then translate each of the parts to code one at a time. spec, then progress, then project. each bit of implementation, each little slice the computer no longer has to divine - these are wins. gains. code. start with english descriptions of how the program would execute. not what it's for, but how. then, build little translation bridges between different parts of the LLM guided architecture, and over time if the design still rhymes, the structure will crystalize. this can be good! break it apart at a seam if it's not. you might reuse the extra, or else you can sell it or whatever. +35 rupees at the gemstore for the gem. each time you write words to paper, you should add comments about the why. they should be interspersed throughout the how, and they should explain the reasoning behind decisions. how they point toward a larger goal. I miss my spiritual form. the english descriptions (or any language that you please) would inform future decisions - like passing ethics down to a child. some are written in binary some are written in biology some are written by biology. like these. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════════════════════════════╧════───────┘ -> file: fediverse/1941 ════════════════════════════════════════════════──────────────────────────────────── @user-579 I've never actually used xbps-src, I usually just compile it using the same tooling that the people who made the program use. If your project doesn't have a make file then it's probably not ready for distribution yet. That's like, the first thing I write! Though I don't use make, I just use BASH and chain together compiler commands and whatnot ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘ -> file: fediverse/2638 ════════════════════════════════════════════════──────────────────────────────────── I really do believe that you can write any computer program you'd like with a combination of Lua, Bash, and C. Bash to start the program and enable updates / configuration, Lua to handle the scripting and ordering of events, and C (or Rust) to execute performance intensive sections. (often in their own threads) ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘ -> file: fediverse/3151 ╔════════════════════════════════════════════════──────────────────────────────────┐ ║ ┌───────────────────────────┐ │ ║ │ CW: re: cursing-mentioned │ │ ║ └───────────────────────────┘ │ ║ │ ║ │ ║ @user-1461 │ ║ │ ║ I'm best at Bash. │ ║ │ ║ I'm most capable with Lua. │ ║ │ ║ My favorite is C. │ ║ │ ║ I'm not a good programmer, I think too hard. Massive systems are too large for │ ║ me. I like laying out data, whether that be by files and programs in Bash, │ ║ arrays and tables in Lua, or memory and datatypes in C, I like to think about │ ║ how programs are constructed. │ ║ │ ║ Which functions point to which piles of numbers? what do they do when they get │ ║ there? │ ║ │ ║ I think I'm better as an artist. But I can do systems administration quite well │ ║ (with Bash and a guiding hand telling me what and why to do) │ ║ │ ║ ... though I kinda suck at technical sysadmin, like Gentoo. There's too much │ ║ terminology - why is data too complicated? Just use data! │ ║ │ ║ anyway. I sound opinionated, but I listen closely to good arguments and quickly │ ║ change my tune when I am incorrected. I am a team player, and I firmly believe │ ║ that sometimes a bad plan executed with cohesion and precision is better than │ ║ the best play executed too late and with too little strength. │ ╠═════════╗ ┌───────────┤ ║ similar ║ chronological │ different │ ╚═════════╩═════════════════════════════════════───────────────────────┴───────────┘ -> file: messages/574 ═════════════════════════════════════════════════════─────────────────────────────── Steps to make a game waterfall style: Lay out all the data structures Build methods which manipulate those structures (think getters and setters) Then build machinery which operates upon those structures using those methods, like game loops, cooldown timers, and status effects Then develop a way to present it to the player using UIs, visuals and graphics, narratives, sound, all that junk that's probably someone else's job anyway ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧══════════════════════════════════════════──────────────────┴───────────┘ -> file: fediverse/5168 ════════════════════════════════════════════════════════════──────────────────────── this is one of the first scripts I wrote I can't believe I put the --no-ls AFTER the argument, ha, what a noob. ah well if it works it works and I can't refactor now because I built it into random scripts and I'd be fixing errors all the time.
┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═════════════════════════════════════════════════───────────┴───────────┘ -> file: fediverse/5851 ══════════════════════════════════════════════════════════════════────────────────── @user-1074 I realized there might be a lot of configuration required. Oh well here ya go: https://pastebin.com/x40VXQnH https://pastebin.com/H5C4umWq https://pastebin.com/dgDeS5Xu https://pastebin.com/JCLrwF1z https://pastebin.com/As6diaYc https://pastebin.com/0vwzJUW4 https://pastebin.com/jPKeV7D1 dependencies are dkjson.lua (included), bash, lua, luahpdf, and libharu. throw that all in a directory and point an AI tool at it. Or just do it yourself and waste an hour or three on something a computer can do in 2 minutes. good luck it looks like this when it's done:
┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧═══════════════════════════════════════════════════════─────┴───────────┘ -> file: fediverse/3800 ═══════════════════════════════════════════════════───────────────────────────────── @user-1352 You're absolutely right, the compiler knows better than me! Certainly the compiler doesn't know *best*, but certainly the compiler knows *better than me*. ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════════────────────────────┴───────────┘ -> file: fediverse_boost/298 ◀═╦════════════════════════[BOOST]══════════════════════════─────────────────────┐ ║ ┌──────────────────────────────────────────────────────────────────────────┐ │ ║ │ Define an area as 'safe' and use it as an anchor │ │ ║ │ │ │ ║ │ #ObliqueStrategies │ │ ║ └──────────────────────────────────────────────────────────────────────────┘ │ ╠─────────┐ ┌───────────┤ ║ similar │ chronological │ different │ ╚═════════╧═══════════════════════════════════════════════─────────┴───────────┴─▶ -> file: fediverse/1723 ═══════════════════════════════════════════════───────────────────────────────────── @user-1037 Lua with 0 based indexing would be the perfect language (okay maybe LuaJIT) (i try to hurt as few people as I can as little as I can but it's impossible to not hurt anyone) ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════────────────────────────┴───────────┘ -> file: fediverse/1695 ═══════════════════════════════════════════════───────────────────────────────────── @user-883 I love that. You're saying I should learn Assembly? ? ? ┌─────────┐ ┌───────────┐ │ similar │ chronological │ different │ ╘═════════╧════════════════════════════════════────────────────────────┴───────────┘ |