Poems similar to: construct

The 64 poems closest in meaning to this word, arranged to spread the colours (progress bar shows chronological position)

Menu │ Chronological


 -> 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
If you only have arithmetical expressions you can use some properties of arithmetic to compute branching computer code. E.G., if A is either zero or one depending on some previously computed condition, then A times B plus (1-A) times C computes the expression "if A then B else C"
┌─────────┐                                                            ┌───────────┐
│ 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
Image attachment
┌─────────┐                                                            ┌───────────┐
│ 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
computer code
┌─────────┐                                                            ┌───────────┐
│ 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.
A screenshot of some C code.
┌─────────┐                                                            ┌───────────┐
│ 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.                                           │
some lua code illustrating a VERY simple Ollama generation function.
╠═════════╗                                                            ┌───────────┤
║ 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:
39 lines of C code included in it's original form here:  #include <stdio.h> #include "pthread.h" #include "raylib.h"  void* draw(void* args){    const int screenWidth = 800;    const int screenHeight = 450;     InitWindow(screenWidth, screenHeight, "template");     SetTargetFPS(4);     while (!WindowShouldClose())    {       BeginDrawing();          ClearBackground(RAYWHITE);          /* do something */       EndDrawing();    }     CloseWindow();    return NULL; }  void* game(void* args){    /* do something */    return NULL; }  int main(void) {    void* args;     pthread_t threads[2];    pthread_create(&threads[0], NULL, draw, &args);    pthread_create(&threads[1], NULL, game, &args);    return 0; }
┌─────────┐                                                            ┌───────────┐
│ 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.
script 1:  #!/bin/bash  # sort by filetype would be nice  alias cd="cd-improved"  function cd-improved(){      if [ "${1}" = "..." ] ; then         builtin cd .. && builtin cd ..     elif [ "${1}" = "...." ] ; then         builtin cd .. && builtin cd .. && builtin cd ..     elif [ "${1}" = "....." ] ; then         builtin cd .. && builtin cd .. && builtin cd .. && builtin cd ..          elif [ -d "./${1}" ] ; then         local target_dir="./${1}"      elif [ "${1}" = "cdir" ] ; then         local target_dir="$(tail -n 1 '/home/ritz/scripts/.cdir-target')"         echo ${target_dir}       else         local target_dir="${1}"     fi      if [ ! "${2}" = '--no-ls' ] ; then         builtin cd "${target_dir}" && ls -v --color=auto     else         builtin cd "${target_dir}"     fi          # if the qcd function is defined     if declare qcd > /dev/null; then         quick_cd -d DEFAULT         quick_cd -a DEFAULT     fi }    script 2:  #!/bin/bash  function cdir(){        if [ "$#" -eq 0 ]; then       pwd | cat >> ~/scripts/.cdir-target    elif [ "${1}" == "-l" ]; then       cat ~/scripts/.cdir-target    fi      }
┌─────────┐                                                            ┌───────────┐
│ 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:
picture of a document with algorithmically generated art picture of a document with algorithmically generated art picture of a document with algorithmically generated art picture of a document with algorithmically generated art
┌─────────┐                                                            ┌───────────┐
│ 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 │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘