Poems similar to: procedures

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

Menu │ Chronological


 -> file: fediverse/1983
════════════════════════════════════════════════────────────────────────────────────
  @user-1037

  I guess I'm saying that for non-standard functions (most of them) they should
  need to make a ticket every time they want to run a function call. Perhaps only
  in debug mode...
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/1982
╔══════════════════════════════════════════════────────────────────────────────────┐
║ @user-1037                                                                       │
║                                                                                  │
║ True, but what they WANT to know and what is RECORDED in record is often         │
║ not-quite the same thing.                                                        │
║                                                                                  │
║ Hence, why laboratory techs feel at odds with the software people running        │
║ applications on their machines. I'm assuming it's roughly the same thing going   │
║ the other direction, though perhaps with a dash of classism thrown in.           │
║                                                                                  │
║ The record is useful to these hardware techs, because they've used it to         │
║ diagnose INCREDIBLY OBSCURE issues. SO MUCH READING it hurts my heart just to    │
║ think about it. Scanning and searching for a solution, until finally it's found  │
║ in this cross-examination of two different ancient tickets from just a few       │
║ months ago.                                                                      │
║                                                                                  │
║ One of them said they set the hardware one way.                                  │
║                                                                                  │
║ the other said they noticed it was out of place.                                 │
║                                                                                  │
║ Suddenly, you realize WHEN your incident started occurring, and then you can     │
║ piece together the facts.                                                        │
║                                                                                  │
║ (this has happened like, twice to me so far, and each time I spent weeks on it)  │
║                                                                                  │
║ ( though I did work at Intel, meaning I was doing a lot of obscure hardware      │
║ work )                                                                           │
╠═════════╗                                                            ┌───────────┤
║ similar ║                       chronological                        │ different │
╚═════════╩═══════════════════════════════════─────────────────────────┴───────────┘
 -> file: fediverse/3095
═════════════════════════════════════════════════───────────────────────────────────
  if your business can't afford to have a back-up plan, then it is not a
  sufficiently prepared operation.
┌─────────┐                                                            ┌───────────┐
│ 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/5542
═══════════════════════════════════════════════════════════════─────────────────────
  @user-1074

  people crave diversity, and their yokes chafe them even as revolution draws
  near. I doubt it'd be possible to constrain them to one set of procedures, no
  matter how equitable.

  Protocol, not procedure.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════────────┴───────────┘
 -> file: fediverse/2293
════════════════════════════════════════════════────────────────────────────────────
  ┌────────────────────────────┐
  │ CW: re: politics-mentioned │
  └────────────────────────────┘


  @user-1218

  true, which is why such an idea should be more than a formality, more than a
  technicality, and closer to a schedule or event-driven system.

  "Well, the duration on this-or-that project elapsed, and the team assigned to
  study it has produced these scientific results. Look on page 7 there's a pretty
  cool graph! What should we try next, to compare with what we just tried?"

  repeat until we all decide that one of the methods we tried was the best, then
  re-implement that one if necessary and mark it as "long-term"
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/875
══════════════════════════════════════════──────────────────────────────────────────
  @user-192

  block input/output TO the protocol? versus the other one which blocks the
  input/output protocol
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: fediverse/4306
═════════════════════════════════════════════════════───────────────────────────────
  ┌───────────────────────┐
  │ CW: cursing-mentioned │
  └───────────────────────┘


  operations: try not to use the last of anything, and always use last-time's
  last first.

  projects: you better clean your fucking plate because anything you don't eat is
  going in the TRASH
┌─────────┐                                                            ┌───────────┐
│ 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/5630
═══════════════════════════════════════════════════════════════─────────────────────
  changelogs are an innovation that bureaucracy could not manage without computers

  and indeed always sets upon your data a time-limit, no matter the
  implementation method
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════────────┴───────────┘
 -> file: fediverse/5143
════════════════════════════════════════════════════════════────────────────────────
  lost my thought

  TECHNOLOGICAL BARRIERS ARE PERFORMANCE RUINING ask any surgeon who dropped a
  scalpel
┌─────────┐                                                            ┌───────────┐
│ 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/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: fediverse/491
════════════════════════════════════════────────────────────────────────────────────
  @user-353

  this is 500% how you get things done in the current system (in my country)
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘
 -> 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: bluesky/27
═══════════════════════════════════════════════════════════════════════─────────────
  you can have as many processes running on a computer as you please, just make
  sure they're all named chrome.exe so the user doesn't suspect a thing.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════┴───────────┘
 -> file: fediverse/3124
═════════════════════════════════════════════════───────────────────────────────────
  I should not have to follow 16 steps that I don't understand just because you
  decided my system wasn't good enough for me.
a long list of steps in order to update a gentoo system to a new version (not even the newest version, I might add)
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: messages/64
══════──────────────────────────────────────────────────────────────────────────────
  https://www.vecmar.com/okidata_491.htm
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════────┴────────────────────────────────────────────────────────────┴───────────┘
 -> file: fediverse/48
═════════════════════════════════───────────────────────────────────────────────────
  ┌─────────────────────────────┐
  │ CW: re: Bottom surgery woes │
  └─────────────────────────────┘


  @user-42 I had complications with my surgery. I wouldn't recommend it if you
  are likely to have a complicated surgery. I'm sorry :(
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════──────────────────────────────────────┴───────────┘
 -> file: notes/cameron-king-resume-programmer-analyst
════════────────────────────────────────────────────────────────────────────────────
  Cameron King   cameronking@protonmail.com   Hillsboro, OR

  Education:

  Experience:

  Skills:
      Analyzes  processes  and  procedures  to  determine  an  effective
      approach  to  programming
  and/or recommendation of systems development.  Tasks are generally divided to
  approximately 50% analysis and 50% programming.

      Applies principles of current Information Systems design methodologies.

      Prototypes the application and associated business processes.

      Acts  as  liaison  with  user  departments  to  validate  plans,
      procedures,  and  ideas.    Creates
  opportunities to partner with and add value to individual departments as they
  accomplish
  their missions.

      Tests and modifies applications and programs.

      Executes and  analyzes utility  programs  in  the  development and/or
      maintenance  of
  application systems and software.

      Facilitates data and data management between equipment platforms.

  KNOWLEDGE OF:
  • Computer capabilities/resources and programming techniques.
  • Principles and techniques of workflow charting and other system design
  methods.

  SKILL IN:
  • Client/server and networked systems design and development.

  ABILITY TO:
  • Analyze procedural operations and to organize their component parts into a
  logical
  system.
  • Analyze and integrate external systems and procedures.
  • Write machine instructions in programming languages currently used by Yamhill
  County.
  • Establish and maintain effective working relationships with co-workers,
  supervisors, and
  user departments.
  • Attend work as scheduled and/or required.

  MINIMUM EXPERIENCE AND TRAINING:
  A high school diploma or GED and three to ten years’ experience in developing
  and maintaining
  computer  application  programs  and/or  three  to  ten  years’  experience
  in  appropriate  computer
  languages  and  successful  completion  of  related  training;  or  any
  satisfactory  combination  of
  experience and education which ensures ability to perform the work required.

  OTHER REQUIREMENTS:
  Ability to secure and maintain a driver’s license valid in the state of Oregon,
  or an acceptable
  alternative  means  of  transportation.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═══════──┴────────────────────────────────────────────────────────────┴───────────┘
 -> file: fediverse/1977
════════════════════════════════════════════════────────────────────────────────────
  functions should be forced to describe the context of why they were being
  called. I think it would help debug a lot if we supplied a reasoning for each
  and every request [function call] that we made. We might even be able to parse
  them into semantic pyramids which we could sorta use to estimate [tree-like
  scanning] how and why the program did do wrong.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/3754
═══════════════════════════════════════════════════─────────────────────────────────
  @user-1071

  You know, that makes sense! Finance plus signing things. Their operations are
  probably more... paper based and contractual than programmatic.

  When I think of devops I think of my time spent as a contractor for a large
  tech company...
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: fediverse/2116
════════════════════════════════════════════════────────────────────────────────────
  a program that bundles another program and compiles it during it's normal
  operation in order to derive a certain purpose which is quickly overwritten in
  memory, so you can't get the full picture of what it does.

  like, a fast moving function that's never really clear in it's purpose.

  because it changes a lot of things that don't really seem to matter,

  like a constant wrestling match over the nature of the computer program.

  which would you rather? a dance, or a death-splatter?

  yeesh, where's my cat, I need something to cuddle.

  she's been distant from me, lately.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/1034
══════════════════════════════════════════──────────────────────────────────────────
  @user-192

  be careful, recursion can cause stack overflows.

  better to run function pointers from a loop. That way you can operate as long
  as necessary. Just make sure you don't get in an infinite loop...
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════─────────────────────────────┴───────────┘
 -> file: notes/memory-is-expensive
═════════════════════════════════════════════════════════════════════════════════───
  computer memory is expensive right now. Not long-term memory, but the short term
  stuff.

  so, programmers should write programs that use misd more than simd.

  simd is graphics cards, it is many, it is small medium and large.

  misd is many smaller processors, it is one, it is atomic in scale.

  simd iterates over data.

  misd changes one frame at a time.

  simd applies routines to all of the data,

  like running functions in a loop,

  misd adjusts from all angles

  like cells in molecular goop.

  each angle, a processor, pointed at shared memory.

  or at least a thread or a core.

  each cell, a part of functionality.

  the molecular goop is the program's timeline.

  the program is abstractable-ing in usage.

  and by timeline, I mean like... "these functions are stored in this place in
  ram, these datas are stored at that place in ram, oh that function just ran so
  let's load it to this particular spot on disk, etc etc" etc etc
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════════╧═════════──┘
 -> file: fediverse/5631
═══════════════════════════════════════════════════════════════─────────────────────
  ┌──────────────────────┐
  │ CW: cursed-maybe     │
  └──────────────────────┘


  installation procedure which runs a bitcoin miner for X amount of seconds, as
  payment for using their free and open source services.
┌─────────┐                                                            ┌───────────┐
│ 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/4900
═════════════════════════════════════════════════════════───────────────────────────
  if you wanna trick systems administrators just put a bunch of sleeps in your
  code so your computer programs don't use up all the mainframe's resources all
  at once

  [statements dreamed up by the practically deranged]
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════──────────────┴───────────┘
 -> file: fediverse/1892
═══════════════════════════════════════════════─────────────────────────────────────
  ┌─────────────────────────────────────────┐
  │ CW: C-programming-and-alcohol-mentioned │
  └─────────────────────────────────────────┘


  I want to write C programs with threads and manual memory management and
  function pointers and lots and lots of arrays and I'm not even kidding

  ... wait a minute I literally don't have a job, why am I not writing C programs
  right now?

  BRB I got something important to do, where's my vodka --> pkill firefox
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: fediverse/3274
══════════════════════════════════════════════════──────────────────────────────────
  "I can't remember that function, it does too few things"
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/3349
══════════════════════════════════════════════════──────────────────────────────────
  @user-1074

  my understanding is, if someone wanted to create something like that, they
  should start with writing protocols instead of standards, much the same way
  Activitypub or HTTP are protocols for a free and open internet.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/1408
═══════════════════════════════════════════─────────────────────────────────────────
  being post-op is like "yay I can finally have sex!" but then you think "ehhh
  why bother, it's a lot of work"

  plus you gotta dilate
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: fediverse/1809
═══════════════════════════════════════════════─────────────────────────────────────
  you shouldn't, generally, do "new" things while sedated.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════────────────────────────┴───────────┘
 -> file: fediverse/5398
╔═════════════════════════════════════════════════════════════─────────────────────┐
║ @user-192                                                                        │
║                                                                                  │
║ step one, doesn't it suck how we have to mount drives                            │
║                                                                                  │
║ part two, gee I sure wish networking was easier than building packets in C and   │
║ pushing them over IP/TCP                                                         │
║                                                                                  │
║ section three, what if every user logged in to the same system of environments   │
║ and kept all their data to themselves while contributing compute to various      │
║ valuable processing processes like windfall calculations and population density  │
║ administrations                                                                  │
║                                                                                  │
║ book four, I wish I didn't have to type -p now when telling my computer          │
║ goodnight, I should write a script that solves that in like 4 lines two of       │
║ which are empty                                                                  │
║                                                                                  │
║ what about five, where they talk about sourcing functions?                       │
║                                                                                  │
║ I like to use recursion - calling my own functions inside of my own bash scripts │
║                                                                                  │
║ "something something modularity" okay docker bro like I'd really package up      │
║ anything that I'm working on                                                     │
║                                                                                  │
║ I mean really who really cares about how I set up the infrastructure of my       │
║ system. it's gonna be unique to each person's memory of setting it up anyway,    │
║ so why bother with "standardization"                                             │
╠═════════╗                                                            ┌───────────┤
║ similar ║                       chronological                        │ different │
╚═════════╩══════════════════════════════════════════════════──────────┴───────────┘
 -> file: fediverse/3787
═══════════════════════════════════════════════════─────────────────────────────────
  arithmatic control flow

  If A, then B. Else C
a picture of a programmatic implementation of arithmatic control flow
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: messages/110
════════════════════════════════════════────────────────────────────────────────────
  The best way to program computers is to organize them according to their
  relations. Like, when x increases by 4 then y increases by 2 - basically, a
  math equation that you can continuously solve by calculating more and more
  comprehensively and deeply.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════───────────────────────────────┴───────────┘
 -> file: messages/527
═══════════════════════════════════════════════════─────────────────────────────────
  could give us some experience organizing small, short-term projects to
  accomplish specific goals and tasks in an ad-hoc way that relied less upon
  procedure and more on "I think so-and-so knows something about that, they were
  looking into those files and posted a breakdown of how they work yesterday"
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════────────────────────┴───────────┘
 -> file: fediverse/1979
════════════════════════════════════════════════────────────────────────────────────
  @user-1037

  "I received a ticket to replace the RAM on system 10b42r77 - I did as
  requested."

  versus

  "I received a ticket to replace the RAM on system 10b42r77 - I verified that
  all sectors of the DIMMs were fully functional, and cleared out the
  operating-system-cache-which-somehow-has-something-to-do-with-the-ram. In
  addition, I noticed that a certain dip-switch wasn't configured correctly
  according to the previously filed and recorded ticket application hardware
  facilitation request. I set it to the correct configuration. Please confirm if
  this configuration would conflict with any of your tests."

  One of them wastes perfectly good hardware chips (RAM), the other saves a few
  milibytes of disc space.

  Who would you rather have in your company?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse_boost/303
◀═╦═════════════════════════[BOOST]══════════════════════════────────────────────┐
  ║ ┌──────────────────────────────────────────────────────────────────────────┐ │
  ║ │ Overheard at the lab: “I don’t understand why people do drugs when they  │ │
  ║ │ could be doing operating systems research instead.”                      │ │
  ║ └──────────────────────────────────────────────────────────────────────────┘ │
  ╠─────────┐                                                        ┌───────────┤
  ║ 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/6022
═══════════════════════════════════════════════════════════════════─────────────────
  the "critical path" is the most useful tool I took from management. [I was
  never a manager]
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════────┴───────────┘
 -> file: messages/28
══──────────────────────────────────────────────────────────────────────────────────
  [File: Grillpill.docx]
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═────────┴────────────────────────────────────────────────────────────┴───────────┘
 -> file: fediverse/572
═════════════════════════════════════════───────────────────────────────────────────
  Hi, I'm learning about semaphores right now and trying to explain them to a
  friend. But I only sorta understand how they work - can anyone look at this
  pseudocode and tell me if I'm on the right track?
Some C pseudocode working through the semaphore design pattern. Here's the text of the pseudocode:  /* no lock example */  void start_thread(int* x) {   *x += 1; }  int main() {   int x = 0;   for (1000 times){     start_thread(&x);   }   print(x); }  /* in this case you have no idea what will print because thread A will take x and be like "ah yes it's 423" and then in the next instruction it'll be like "I'll increment this to be 424" and in the next one it'll say "okay now it's time to store 424 in the variable X" but like... there's a thousand threads all doing that at the same time, so odds are you'll have 5 that are like "ah yes this is 423 I'll set it to 424" */  /* not a good plan. Need a lock, so only one thread can use it at once. */ /* mutex example: */  void start_thread(int* x, int* x_mutex) {   *x += 1;   *x_mutex = 0; }  int main() {   int x = 0;   int x_mutex = 0;   for (1000 times){     while (x_mutex != 0){ } /* do nothing */     x_mutex = thread_id;     start_thread(&x, &x_mutex);   }   print(x); }  /* this should print 1000, but it's basically as slow as doing it single threaded. */  #define MAX 10  void start_thread(int* x, int* x_semaphore) {   *x += 1;   *x_semaphore += 1; }  int main() {   int x[MAX];   int x_semaphore = MAX;   for (1000 times) {     for (int i = 0; i < MAX; i++) {       x_semaphore -= 1;       start_thread(&x[i], &x_semaphore);     }     while (x_semaphore != MAX) { } /* do nothing */   }   int value = sum(x, MAX);   print(value); }
┌─────────┐                                                            ┌───────────┐
│ 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_boost/298
◀═╦════════════════════════[BOOST]══════════════════════════─────────────────────┐
  ║ ┌──────────────────────────────────────────────────────────────────────────┐ │
  ║ │ Define an area as 'safe' and use it as an anchor                         │ │
  ║ │                                                                          │ │
  ║ │  #ObliqueStrategies                                                      │ │
  ║ └──────────────────────────────────────────────────────────────────────────┘ │
  ╠─────────┐                                                        ┌───────────┤
  ║ 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/1473
═══════════════════════════════════════════─────────────────────────────────────────
  @user-883

  yeah uhhhh the one you helped me setup. The error is just "connection refused"
  because it "could not write header for output file" because of incorrect input
  parameters, but I don't think I changed anything since we used it a couple
  weeks ago. Have you seen any errors like that?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════────────────────────────────┴───────────┘
 -> file: fediverse/1976
╔══════════════════════════════════════════════────────────────────────────────────┐
║ when pushing ctrl+v, the operating system first checks the file-type of the      │
║ content being submitted.                                                         │
║                                                                                  │
║ if it's like, a .jpg or .png, it knows that it's an image file. Do note that     │
║ these are RANDOM letters that mean nothing, not something informative like .pic. │
║                                                                                  │
║ if, however, it is text-based information, it first reads what is being sent to  │
║ the application which is requesting a ctrl+v.                                    │
║                                                                                  │
║ Then, upon reading said information, it decides "is this worth passing on?       │
║ Should I send something else, based on the results of what I've been analyzing   │
║ of the situation as it develops over time, being observed by the execution       │
║ operations of the monitor, which is projected forward unto the screen? (totally  │
║ forgetting that "virtual" monitors exist, meaning monitors that don't display    │
║ to any physical screen, but which rather are projected into the computer's       │
║ "aetherspace", an area which is purely of the mind.                              │
║                                                                                  │
║ Alas, that other sensors might not have read from this area. That they might     │
║ not observe the results of the operations pe                                     │
╠═════════╗                                                            ┌───────────┤
║ similar ║                       chronological                        │ different │
╚═════════╩═══════════════════════════════════─────────────────────────┴───────────┘
 -> file: fediverse/2859
═════════════════════════════════════════════════───────────────────────────────────
  ┌───────────────────────┐
  │ CW: cursing-mentioned │
  └───────────────────────┘


  large corporations will often error check *constantly* which slows down their
  software to an immense degree.

  every time data passes from one function to another, there's like... 15
  different tests to check if it's this type or that, or in the right random seed

  and it's like... wow can you not, like. design your software intelligently and
  then you won't need a bunch of slow-ass if checks every time you want to update
  a string???

  software should be writable without fucking getters and setters. If it isn't,
  then your functions aren't complete.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: fediverse/1988
════════════════════════════════════════════════────────────────────────────────────
  @user-246

  I once heard that Excel is a functional programming language with a tabular
  interface
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/5617
═══════════════════════════════════════════════════════════════─────────────────────
  it should be a legal requirement that any data gathered permanently or
  semi-permanently on a user of software must ALSO make a copy on the user's
  device.

  WITH change-history and graphs.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════────────┴───────────┘
 -> file: fediverse/5214
═════════════════════════════════════════════════════════════───────────────────────
  @user-1773

  what if all programs had legally mandated APIs which had to be called every
  time text was displayed on the screen which wrote to a piece of shared memory
  with read-only privileges that could be read by text-displaying applications?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════──────────┴───────────┘
 -> file: fediverse/6061
═══════════════════════════════════════════════════════════════════─────────────────
  what if (hear me out)

  what if instead of TCP we just did a constant stream of UDP packets until the
  recipient said "OKAY OKAY I GET IT"
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════════────┴───────────┘
 -> file: fediverse/5457
═══════════════════════════════════════════════════════════════─────────────────────
  ┌───────────────────────────────────────┐
  │ CW: trans-sex-and-sexuality-mentioned │
  └───────────────────────────────────────┘


  being post op basically feels like "what if your buttcheeks went all the way
  forward"
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧════════════════════════════════════════════════════────────┴───────────┘
 -> file: messages/944
════════════════════════════════════════════════════════════════────────────────────
  more viewpoints, more data. sorta like taking 3d pictures of a 2d object.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════════───────┴───────────┘
 -> file: fediverse/3226
══════════════════════════════════════════════════──────────────────────────────────
  if your man page is longer than a list of options and their usage and a
  paragraph or twenty of how to use the software... then you need to abstract,
  and break your code into multiple purpose-built applications.

  do one thing, and do it right. alternatively, do one set of things, and do them
  concisely.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/5229
╔════════════════════════════════════════════════════════════──────────────────────┐
║ what if programs just checked the current state of the program against their     │
║ past memory of it every time their looping functions got to the end of a new     │
║ kind of while loop which checked the previous state of all the variables in the  │
║ system as compared to the arguments of the function that is called by the new    │
║ kind of while loop which look exactly the same as the last memory of the         │
║ program. Okay. Let's write it to RAM and then start working on the next one.     │
║ Once we run out of space or the operating system needs more, we can relinquish   │
║ the oldest ones. The idea is to store state after all which could be             │
║ programmatically checked to make sure it didn't change underneath our feet.      │
║ Then you pretty much wouldn't need to worry about buffer overflows or            │
║ cybersecurity incidents at all...                                                │
║                                                                                  │
║ after all, it's only read only. what's the harm in reading our tax               │
║ documentation?                                                                   │
║                                                                                  │
║ anyway, something about functional programming languages like lisp passing the   │
║ entire state of the program to each recursion...if you use that kind...          │
╠═════════╗                                                            ┌───────────┤
║ similar ║                       chronological                        │ different │
╚═════════╩═════════════════════════════════════════════════───────────┴───────────┘
 -> file: fediverse/3301
══════════════════════════════════════════════════──────────────────────────────────
  "this program that used to work doesn't anymore because, uh, your video drivers
  are out of date."

  ... okay but if I didn't update this program either, then why would it matter
  if my video drivers are out of date? wouldn't they be working off of the same
  [rulings/requirements]?

  the "best practice" of updating your software all at once instead of one-by-one
  is a disaster for our humankinds consequences or whatever
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/3173
═════════════════════════════════════════════════───────────────────────────────────
  you've heard of an array of function pointers, yes,

  but have you ever heard

  of an array of GOTO labels?
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════──────────────────────┴───────────┘
 -> file: fediverse/6166
════════════════════════════════════════════════════════════════════────────────────
  Computer programming has always been the practice of applied abstraction. At
  what level do you wish to apply your reasoning, and what level do you wish to
  trust others? I have no idea how the Linux kernel works.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════════════════════════───┴───────────┘
 -> file: fediverse/3543
══════════════════════════════════════════════════──────────────────────────────────
  @user-777

  my favorite thing about specialization is that not everyone has to do everything

  (translate *that* into C lmao)
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═══════════════════════════════════════─────────────────────┴───────────┘
 -> file: fediverse/6313
═════════════════════════════════════════════════════════════════════───────────────
  ┌─────────────────────────────────────────┐
  │ CW: scary-biomedical-cannabis-mentioned │
  └─────────────────────────────────────────┘


  replacement tooth which is basically just a port to your bloodstream to slowly
  diffuse THC / other medications into your body, bypassing the liver.

  "ah but people don't wanna replace their tooth"

  lotta people have crowns. isn't that similar?

  "ah but the tooth doesn't really touch the bloodstream"

  oh, oops. nevermind. wait, does it? I'm not a dentist!!
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧══════════════════════════════════════════════════════════──┴───────────┘
 -> file: fediverse/2302
════════════════════════════════════════════════────────────────────────────────────
  ┌──────────────────────┐
  │ CW: pol              │
  └──────────────────────┘


  laws should have three layers of abstraction.

  a simple version, that you can understand and talk about on the couch.

  a well defined version, that explains exactly in detail how this law will be
  achieved,

  and a precise version, which will basically be programming in legalese.

  with these three layers of abstraction, all representing the same whole, it
  should be easier to contribute to a democracy.
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘
 -> file: fediverse/2566
════════════════════════════════════════════════────────────────────────────────────
  ┌──────────────────────┐
  │ CW: re: mh+, nix     │
  └──────────────────────┘


  @user-1286

  I totally agree! Every time I install new software I write an "update" and
  "run" script so that I can easily use software that I haven't touched in a
  while.

  once I started doing that the usability of my system went way up. Unless they
  change the installation requirements, grrrrrrr
┌─────────┐                                                            ┌───────────┐
│ similar │                       chronological                        │ different │
╘═════════╧═════════════════════════════════════───────────────────────┴───────────┘