sargstuff

{comment : "your comments here!"}

{copyright comment : "JSON doesn't require/enforce specific comments is a good thing" }

{comments : "JSON parser is not an 'comment' editor! }

Don't know whtat the google plus article covered, but Crockfor's comments : https://www.linkedin.com/posts/douglas-crockford-724600109_j...

Less portable, but more related to the dashboard concept, dynamicaly update xterm title[0] so closed xterm shows 'stats' as xterm title.

Perhaps include time panel last opened, number of 'unread' messages since last open, last 'message header', title updated everytime 'awk' sends info block to terminal display.[0]

When window opens, lists grouped information (ala editor style and/or headerless browser[1]) -- reset 'last opened' and number of messages read since last open!

Do keep in mind raw input/output does introduce potential security issues -> ANSI terminal security discussion [2]

-------

[0] a) https://serverfault.com/questions/35085/set-xterm-putty-wind...

    b) https://stackoverflow.com/questions/6526777/change-title-of-xterm-from-a-bash-script

[1] : headerless example using vim : https://github.com/instant-markdown/vim-instant-markdown

[2] : ANSI terminal security discussion : https://news.ycombinator.com/item?id=37957397

?? scripting language where output of one or more 'tabs' is aggregated into single terminal screen. Use shell script to provide tab url to curl, awk to filter on tag blocks from url/relevant tab, direct output to common terminal interface (unix pipe) and shell script to read from common terminal interface to display to "dashboard" and/or actively update html file readable from web browser.

zenity[1] as gui wrapper to above (vs. cli)

[1] : https://en.wikipedia.org/wiki/Zenity

Perhaps trying some of the on-line open courses at universities of interest to size up offerings relative to interest. Would like to say figure out 'challenge level' but, introductory / lead in courses tend to be more get up to speed in given area. aka jumping in to deep end of pool or 1ft wading area.

Post-degree plans are to stay in academia or non-academia work? (degree focus on theory vs. applied theory)

Know what concentration are going to do in graduate school?

If yes, then making sure undergraduate degree program aligns with anticipated graduate degree. aka not distracted / incure extra expense taking 'extra' classes to 'get up to speed' on background for graduate classes. example: CS undergraduate degree not heavy in math, but anticipated CS graduate degree is very heavy on math background. (database engineering - CMU vs. CT (computed tomography) software - MIT)

Community college to university would be one approach to earning credits while figuring out what aspect of CS interested in pursing a graduate/undergraduate degree.

Seek out mentors and places to directly/indirectly use/practice/apply "in real world" what learned in CS classes. Note ideas/suggestions from instructors about things would have liked to cover in class, but not enough time. Note ideas / things that catch one's attention when doing hobbies / clubs / related free time activies. Try applying things from CS classes. aka one off database of classes, grades, anticipated food/food budget as related to degree plan / 'free months off' before completion of degree.

concept idea: can one make a completely 3d printed fax machine? [6][7][8] aka re-invision things with knowledge have (or learn more about what knowledge gaps have & fix it!)

Look at that plan B that can/is supporting persuit of plan A. Note: Plan B might have come from checking out above suggestions. Plan B might become better deal than Plan A!

?? Read up on history's, didn't plan it this way, but worked out because "right place, right time" aka apple/xerox alto[4]; michael dell/dell computers; facebook; musk & paypal; home brew computer club; "chocolate bar to microwave"[2]

Learn to use what have available to use/do something with (ideally as way to exercise/reinforce CS stuff - aka hackathons. ). Keep at it until have something that someone unfamiliar with what doing would be able identify it as related to computer science stuff.

Keep a 'cs journal'[5]

Humor - A key ingredient to engagement, meaningful connection, and creativity in youth development.[0]

Wit and Humor [1]

in search of a boaring business [3]

-------------------------

[0] : https://blog-youth-development-insight.extension.umn.edu/202...

[1] : https://www.theatlantic.com/magazine/archive/1907/09/wit-and...

[2] : https://www.technologyreview.com/1999/01/01/236818/melted-ch...

[3] : https://www.nytimes.com/2025/03/12/business/young-profession...

[4] : https://web.stanford.edu/dept/SUL/sites/mac/parc.html

[5] : https://medium.com/@holasoymalva/how-to-make-a-programming-j...

[6] : https://nano3dprint.com/?utm_term=3d%20printed%20circuit&utm...

[7] can it be done without 3d printing electronic circuits? https://en.wikipedia.org/wiki/Fax

[8] https://www.youtube.com/watch?v=gTvPC_hkeGs / https://www.youtube.com/watch?v=KCzMLl-cB94 / dynamic view master! : https://www.youtube.com/watch?v=AOQi4BmXRAo

anaology and the roots of creative intelligence : https://thereader.mitpress.mit.edu/analogy-and-the-roots-of-...

notes on precise and serendipitous creative tools : https://indefiniteusage.substack.com/p/notes-on-precise-and-...

Work on developing professional / non-academic connections. aka ACM, IEEE, local 'clubs/organizations', relevant open source projects. This provides broader exposure to those looking to hire while also building one's credentials / show casing what interested in applying degree to. Demonstrates knowledge of how to use academic credentials outside of academic setting.

Insite: Everything else being equal, is someone one knows/familiar with someone's work more or less likely to hire an unknown or someone who's work/project(s) is familiar/known.

Lisp take on generating an embedded VM at runtime/ad hoc basis (vs. polymorphic coding)?

How would use the most recent 'trie of lisp git diffs' differ from command to do a system call fork of lisp / duplicate lisp lists / apply 'diffs' to forked system call of lisp?

Perhaps, lisp concurrency support without a system()/debugger.[1]

(humor) To bad iLisp would be confused with other brand name(s).

[1] : Evil Scheduler: Mastering Concurrency Through Interactive Debugging : http://aoli.al/blogs/deadlock-empire/

It's the difference between the way things are accessed/handled behind the scenes in a spreadsheet vs. database[3][1b].

Adding a programming / scripting language isn't going to change exel data access patterns.

One possible approach:

Using excel as front end and storing actual data in database would speed things up. This assumes one uses 'python' on the database to do behind the scenes analysis[1] vs. moving complete excell worksheet(s) into / out of database[2]).

Relevant background note: Spent quite a few years supporting researchers who were comfortable with excel; but the basic data requirements far exceeded what excel was capabile of handling (pre-analysis, 1-2milion excel cells). aka local machine access only, no remote / cloud stuff.

---------------------------

[1] : a) excel with access database : https://www.youtube.com/watch?v=-DbvcuE8ITA b) excel with postgres : https://rowzero.io/blog/connect-postgresql-to-microsoft-exce...

[2] input/export excel data : https://www.youtube.com/watch?v=9PxaTPZIYmc

[3] why database instead of excel : https://baserow.io/blog/database-instead-of-excel

Ok, kinda sounds like mixing apples and oranges.

Are the multiple long-running worker processes working on distinct tasks (aka each is the equivalent of starting a distinct individual process/program with no dependencies)

?? worker process that are awaiting data to process ??

simplified related bash shell examples :

aka guarantee sequencial process running : https://unix.stackexchange.com/questions/305039/pausing-a-ba...

vs.

wait for all processes to end (can be modified to continual request for next thing(s) to do) : https://stackoverflow.com/questions/356100/how-to-wait-in-ba...

Can not understand what original designer(s) intent / thought process was unless there's documenation (physical and/or comments). As software complexity increases, using educated guesses / testing becomes more difficult to do in way that doesnt' introduce other issues. (vs. relevant documenation / explaination). Lot of times easier to start from scratch than do guestimate thinking/approaches.

NASA has a long term/historical projects with public documenation about supporting long term project issues.

TX company that still uses punch cards (2013): https://www.chron.com/news/article/Conroe-company-still-usin...

Shrinking large moving mechanical devices down to something that isn't going to chop off / cause physical body harm certainly would be in the 'less dangerous' department. (newer tech, high electrical voltages not withstanding) But not having to think about how something works / purpose can certainly lead to dangerous abuses as much as new/creative uses.

IMHO, the pitfalls are in not understanding/being aware of the limitations/edge cases. aka Not unplugging 70's CRT TV meant TV still drew power vs. unplugging meant took longer for CRT to warm up before being able to display image. Note: For areas with frequent electical storms, power surge due to lighting strike could destroy plugged in 70's TV. Today's battery powered displays, dropping from height & destroying display more relevant risk than worrying about lighting strike causing power surge.

Unlike most mechanical hardware where have to design upfront to minimize costs/ensure things fit/work together; with software one can very easily intentionally/unintentionally 'sweep things under the carpet" in quest to 'get it done'. see [1] vs. [3]; [2] vs. history of [4];

Quote by Arthur C. Clarke : "Any sufficiently advanced technology is indistinguishable from magic."[5]

mechanical digital camera[2]; 1800's Fax machine[4]

niplo disk [1] vs. flexible dot-matrix display manufacture by offset lithography [3]

Related "Ask HN: Is human technology advancing faster than human wisdom sustainable?"[6]

-----------------------------------------------------------------------------------------

[1] niplo disk : https://web.archive.org/web/20091026194656/http://geocities....

    ben heck's mechanical television (part 1) : https://www.youtube.com/watch?v=eI0TtyVEcs8

[2] mechanical digital camera : https://www.youtube.com/watch?v=KCzMLl-cB94

    (vs. 1st digital image (1957) : https://www.nist.gov/mathematics-statistics/first-digital-image )

[3] : (behind paywall) flexible dot-matrix display manufacture by offset lithography : https://repository.lboro.ac.uk/articles/journal_contribution...

[4] : (electro-mechanical image) : The history of faxing: from revolutionary to digital evolution in 2024 : https://novatech.net/blog/the-history-of-faxing-from-revolut...

[5] Aurthur C. Clarke quote disucssion : https://lab.cccb.org/en/arthur-c-clarke-any-sufficiently-adv...

[6] Ask HN: Is human technology advancing faster than human wisdom sustainable? : https://news.ycombinator.com/item?id=43357677

Load balancing / APIs / latency / replicating data is usually handled at OS level (drivers, 'database as an os', traditional 'os', 'caching', memory,hard drive, network load balancing )

Programming languate data structure level detail : "Database Internals, A Deep Dive into How Distributed Data Systems Work" by Alex Petrov

Wouldn't recommend starting of with a <insert item of interest> standards committee. Do learn way more than ever thought possible / would want to know about <insert item of interest> that people feel are relevant to given standard committee is in charge of.

One approach: Pick something that was at the time 'state of the art' and envision what would constitute 'state of the art' today. 1800's good for steam punk approach. Describe what existed at the time of 'original state of the art' and how that changed to current state of the art aka standards, techniques (black smith to all digital chip/embedded laser scan). Learn quite a bit about how things came to be & underlying abstractions/standards that 'simpify'/'unify' things.

Keep open mind about Alexander Fleming approach to 'bugs' in an experiment. (did that old ME design bug faithfully get replicationed in the software, intentionally or unintentionally?)

###

   ** 1800's telegraph engineer solution to needing multiple telgraph wires vs. current version of usb

   1800's fax : https://www.damninteresting.com/curio/the-fax-machines-of-the-1800s/

###

   ** K&R C vs. Published C standards (iso or otherwise) always fun way to find intersting things to explore (applied to hardware or not hardware applied). 

   ** RFC's bit less 'wordy'.

###

   ** awk progam(s) to use/interpret BNF in real time to provide "modern" constructs for awk programming. (or impliment way to read/interpret lambda expressions in awk to extend awk)

   ** ( as a learning tool/approach a scaled/toy awk scripted version of dbos )

   dbos :  https://www.google.com/search?client=firefox-b-1-d&q=dbos

###

   ** Nipkow mechanical tv 1920's vs. python/pi implimentation! (or Philo Farnsworth's take)

   mechanical tv : https://www.youtube.com/watch?v=R-wbfP1pmVw

   Farnsworth : https://en.wikipedia.org/wiki/Philo_Farnsworth

###

   ** foucault's measurements vs. LIGO vs. Fizeau Apparatus
   
   https://en.wikipedia.org/wiki/Foucault%27s_measurements_of_the_speed_of_light

   measuring speed of light : https://www.youtube.com/watch?v=R-wbfP1pmVw

   LIGO : https://en.wikipedia.org/wiki/LIGO

   Fizeau Apparatus : https://www.youtube.com/watch?v=YMO9uUsjXaI

###

   ** MUMPS vs. current 'concurrent' databases (postgres).

   MUMPS : https://en.wikipedia.org/wiki/MUMPS                                       

###

How to loop in a loopless language might be useful for going from "spinning disks" to 'trees' : https://www.youtube.com/watch?v=qzsxO79zxS8

Can not find the HN post about challenge of finding if on a closed path within a given plane, there exists at least one rotatable square(?). 2 parallel lines have been proven.

There's a simple mechanical device that provies a simplified representation of wave propigation from a given normal to point on path from which to start/generate search for '4 square points'. aka radar 180 wave propigation with two points returning from same time interval would generate canidate points to check for corresponding normal triangle arc points on the other 180 degrees from normal. aka physics wave tank & wave generate from physical sheet movement (in this case just up/down oscillation of path point normal). -- way more simple to capture via math than describe, but some pretty heavy math theory to understand/interpret equations. problem with math is generating/capturing a time interval that links the 'pond ripples" from path point normal in order to derive the 4 equi-distant points at 90 degree arc intervals from a canidate 'ping' point.

aka moving the normal to path point up/down in 'wave tank' and using ripples out from normal path point to simulated changes in normal to path point length to find a point that lies along the closed path to see if 3 other derivable square points exist on the closed path. max propigation to look at is the minimal 45 degree angle square that can contain the full closed path.

It's a variation on the question of can two or more base terms be used in give context. (classical vs. quantum instance)

a & b are two back to back radars. parallel line of 180 radar a, with parallel line of 180 b. at time index a, if results of a - b cancel out, then there's a square along closed path.

time t of 4 points has to correspond to normal of point on path. Maximum propigation distance is the size of the square box that can completely contain the closed path.

On a ligher note: It's the practical application of enclosing oneself inside of a box, with a board & saw. In order to get out, you cut the board in half and then put the two halves back together to get a whole/hole. The whole/hole in this instance being the normal/rope which provides a singularity link to both the square box with 4 points on the closed path and the associated normal to point on closed path line. Which kinda makes it sound like all one really needs is a naked singularity within proximity to schrodinger's cat to figure things out.

So, if one used water transport device upon which one moves up and down to stay afloat & move along the 'close path" of interst; should be able to find the 'squares' of the path by tracing back circular water ripple intersections on path points via video analysis. 4 ripple radii == 1 point on path == 1 square.

ANN should be able to work out the likely hood of the line path proximity density to ripple density relative to bounding box enclosing the closed path in order to get the likely hood of number of square boxes that exist with 4 points on the closed path.

Humanities way of genreating blue screen without using a computer (aka. interpretations of trigonometry sine & "i"):

a) Why calculus for y-combinator.

b) What happens when subdivide attention and add to many atomic locks.

c) result of separating logic from imagination -> logical type face issues.

Possible humanities interpretations of trigonometry sine & "i":

a) Why calculus for y-combinator.

b) What happens when subdivide attention and add to many atomic locks.

c) result of separating logic from imagination -> logical type face issues.

Might want to try learning scripting/shell scripting. Automated/flexibile/multiple ways to 'git' it!

Advanced ideas provided as indirect guide/way to learn how to get up to speed.

Starter ideas that one can do stream the workflow with git/shell scripts -> automate conformance to code documentation/formatting; notify relevant reviewers via email notice.; customized log(s); email/regenerate developer documentation references; check-in automated testing (aka fail any of the test, need to go back and work on things before updating with 'git'); set up self contained developer docker to place retreived git stuff in so don't screw-up local machine/allow for consistent development environment between developers.

example reference links culled from search engine search "git and shell scripting":

   git/shell automation : https://jishnun789.medium.com/git-automation-using-shell-scripts-e420767df36f

   advanced bash-scripting guide : https://github.com/rootusercop/Free-DevOps-Books-1/blob/master/book/Advanced%20Bash-Scripting%20Guide.pdf

   advanced git course : https://indico.cern.ch/event/1334738/contributions/5814285/attachments/2833252/4959870/git-good.pdf

   advanced git tutorials : https://www.atlassian.com/git/tutorials/advanced-overview
  
   how to learn linux shell scripting for devops : https://devopscube.com/linux-shell-scripting-for-devops/

#####

alternatively, while learning emacs/emacs shell, practice/re-enforce emacs/lisp/scheme with something other than more traditional sh/csh/etc.[0]. :

or more fanatically modern, dune shell (bash/lisp)[1]; babashka[2]; scsh[3]

------

[0] : lisp as a shell : https://www.cliki.net/Lisp%20as%20a%20shell

[1] : dune shell : https://hackaday.com/2024/09/20/get-your-lisp-on-with-the-du...

[2] : babashka (clojure shell & book) : https://github.com/babashka/babashka

[3] : scsh (scheme shell) : https://github.com/scheme/scsh

      emacs geisesr support for scheme shell : https://github.com/rmloveland/geiser-scsh

      scheme ideas for shell :  https://www.reddit.com/r/scheme/comments/3as8yr/scsh_collection_of_links_related_to_the_scheme/?rdt=53022

re: > see information about sql queries from shell command line. aka nosql - oci cli [1]

Note: field orders must be same for remote odbc & local rust data.

remote odbc ordered dumping of 'sql query' in json format to file 1.

local rust ordered dumping of 'sql query' in json format to file 2.

Do a diff between file1 & file2. 'empty result', specified types match. non-empty result, then may be a more data in one file than other, type mismatches, 'name' mismatches, or something else.

sticking to the 'only use sql' theme:

Instead of file1 and file2, can dump to temporary table1 and temporary table2.

'Flatten' each individual json record before table insertion! (may need to introduce record order number as index.)

json for file1 is in single column, json for file2 is in single column. join on 'string similarities'. -- 'null values' in one field but not in another indicate unmatched pair. -- may be data type or 'value type', requiring additional sql query to get at needed data type mismatch.

A food for thought. If one combines multiple individual baking/cooking receipts not designed to be 'combined' will that result in same kind of result of one recipt with multiple parts (aka designed as one part, with multiple groups of steps). Taste testing the results, might lead to ideas on how to correct the first 'concatination' of receipts to 'taste' more like the 'composite' recipt.

Why would an AI-assisted coding design for the big picture if only has knowledge of one part without concept 'fits into other parts' to make a whole design.

Generating algorithm descriptions and combining the algoithmic descriptions (to smooth/normalize the algorithm as a whole) before generating code from algorithm would make things bit less fragmented. (same concept of compiling to intermediate code, then on each individual type of hardware architechture, translating the intermediate code into something runable on particular hardware architechture.)

Incomplete specifications cause problems for humans. AI's learn from humans. Why would an AI learing from 'incomplete specifications' infer what the 'correct specifications' are (without being requested to do such an analysis)?

see information about sql queries from shell command line. aka nosql - oci cli [1]

database schema data can be queried to find the table(s) field name & table(s) type. That is an additional separate sql query though & would potentially be different for different databases & database versions.

ODBC protocol was designed to address the 'different database schema formats' issues via a 'universal database access' interface. (vs. jdbc, java language equivalent of odbc)[2].

The command line program, usql[3] provides support for sql querying different databases.

Setting sql query to output query results in json format would provide relevant information such as field name & data type within the sql output data. note: sql allows for renaming table names within the sql query. aka select tablea.first_name as surname

----

[1] : http://docs.oracle.com/en-us/iaas/tools/oci-cli/3.51.9/oci_c...

[2] : https://en.wikipedia.org/wiki/Open_Database_Connectivity

[3] : https://github.com/xo/usql

Frameworks / ORM are just specilized database user interface front ends designed to simplify how data can be used (displayed/inputted/manipulated). They can also display known databases/table, such that the user just has to select what's needed (or doesn't have to worry about tables/field -- just the display/forms to get results.

Database management systems usually provide a way of importing/exporting 'raw' data via sql statement(s) results. aka cvs, comma delimited, html formatted, json formatted.

Outside of a framework/ORM from command line / operating system shell; can do a command line sql query with 'html formatted output' and open results of file in a brower. Obvious catch of not using 'tools/environment' is gotta do all the data input cleanup/checks; output formatting for display/printing, such as only want 4 lines of output per printed page. Note: will have to provide database(s) to access information from via databases specific method!

example programs that provide access to sql via command line:

   postgres psql provides an interactive 'cli' environment for using sql 

   windows sql server - sqlcmd;

   usql[1] provides something similar to psql for no-sql databases.

---

sqlc is sorta the equivalent of combining the command line shell & sql queries. The 'c' portion of sql, is c language. So, outside of sql, on own to write what ever 'shell' functionality needed using c.

SQLx rust is rust extention for handling 'sql from command line, just via rust language, instead of going through command line shell.' except, rust language also handles the internet protocols/language extentions for doing rest crud / sql / rust in a single app.

There are program(s) usable from a command line shell (cli) that would provide 'rest crud'.

Different levels of packaging provide differing levels of control/amount of hoops have to jump through. (just raw data, data & usage, just usage)

Unlike databases, spreadsheets provide an interactive gui up front, with 'embedded language' providing the 'data manipulations' aka visual, python, etc. spreadsheet data can be retreived from / sent to a database.

----

[1] : https://github.com/xo/usql

Related:

Animations vs. Coding[0]

ASCII Typography and Greyscale shading[1]

----

[0] : http://news.ycombinator.com/item?id=43226761 [1] : https://news.ycombinator.com/item?id=43226903

Review/look at anything that has an abstraction / implimentation aspect (aka protocols / specifications / design implimentations / public "source material") .

Examine how things are stratified (deterministic vs. context sensitive 'deterministic group(s)' -- and what influences determinism/context sensitivity). aka iso/osi network communications model[4].

Keep in mind K.I.S.S. / occam's rasor philosophies!

--------

a) pick just a single logical plane/level to look at within a design stack. aka -> database & sql; database & hard drive storage; hard drive storage layout (OS vs. drive physical layout & drive storage/reterival (scsi vs. non-scsi api)

a) Any foundations of math class.

b) Simple physics problems with single logical type that be described by math eqation(s). aka no multivariate analysis.

c) "LISP: A Lanaguage For Stratified Design"(1987)[0] by H. Abelson and G. Sussman. (vs. Structure and Interpretation of Computer Programs)

d) A "Git" softare repository (where should be separation between OS, main mechanics of program, libraries, "implimentation details", etc)

e) Expert C Programming: Deep C Secrets by P van der Linden

d) Look at comparisons between types of mechanical engineering geers and associated logical groupings & how that'd correspond to electrical engineering boolean logic / pc 'units' aka add-in boards; processor types, gpu,cpu, etc aka rotational to linear motion / find that info on the hard drive disk : https://www.youtube.com/watch?v=MZ-1PQGlrmY

e) picture to excel[1] :

f) design / implimentation of <insert relevant programming language / kernel / system> [2][3]

From Civil Engineering aspect, pouring concrete, logistical decomposition done by determinisic tasks with respect to external/intermal time effects on 'density changes'. aka getting everyting (including mixed concrete) on site before concrete goes from indeterminate/non-finite form to deterministic/final form. (where different material densities of concret make for a more complete manuver than just a move from pt a to point b logisics). aka acutely aware of gravity of situation.

----

[0] : http://dspace.mit.edu/bitstream/handle/1721.1/6064/AIM-986.p...

[1] : picture to excel: https://www.youtube.com/watch?v=UBX2QQHlQ_I

[2] : smalltalk : http://dl.acm.org/doi/10.1145/512760.512762

[3] : unix file system : http://www.r-5.org/files/books/computers/internals/ifs/Steve...

[4] : network models : https://medium.com/@gwenilorac/understanding-network-models-...

"type checking" would seem to be somewhat field dependent. aka treesitter for physics isn't exactly a direct reference to math[2][4].

Historically, checks for good/appropriate type impressions/groupings were not the responsibility of the blacksmith[0][1].

Physics drives math development via physics need to have math/mathematical explanations that correspond to physics observations/phenomina.

Type checking isn't a math thing, it's a make sure not mixing up math equations describing one type of physics phenominon are not mistaken/mixed up with/for unrelated type of physical phenominon. aka apples to oranges comparison. calculus reduces physics math complexity compared to algebra.

'pc world take' : cpu designer is not responsible for C language type mismatches. cpu implimentation can certainly make things easier/more difficult for C language comiler design/implimentation.

(sigh), not enough space for morse code/lambda calculus/(lisp/scheme) vs. (ascii/utf)/kleene*/(asm/C) discussion. Guess nod to Lewis Carrol "Through the Looking-Glass" will have to suffice.

------

[0] : https://letterpresscommons.com/type-founding/

[1] : linotype : https://blogs.loc.gov/headlinesandheroes/2022/06/the-linotyp...

[2] : intro to treesitter : https://tree-sitter.github.io/tree-sitter/

(missing apple reference)

[4] : niovim & treesitter : https://github.com/nvim-treesitter/nvim-treesitter

"How to export gmail to google sheets or excel without code or appscript" : http://www.youtube.com/watch?v=CjH_rv6nujg

Yeah, full color simulated iee nimo tube displays with a more modern pin interface via arduino![1]

Post script compatible flip dots using an arduino! [2]

inexpensive replacements for rare fiber optic displays! [3]

easy way to make flexled utf compliant![4]

link spreadsheet cells to corresponding set of fiber flip-dot buttons[5]/[6]. for the more turing complete / engineering minded[7]/[8]

Ok, enough normal Babbage about Apes, Taylor, and Laplace.

----

[1] : iee nimo tube display : https://www.youtube.com/shorts/5bMWp9MY3Bc

[2] : http://hackaday.io/project/159415/gallery#6040e2625adb34d5f6...

[3] : super rare fiber-optic displays : http://www.youtube.com/watch?app=desktop&v=gDhewwJNK0A&t=442

[4] flexled : https://hackaday.com/2019/07/09/flexled-is-a-unique-take-on-...

[5] picture to excel : https://leondrolio.com/apps/pixel-spreadsheet/

[6] pdfscale : https://github.com/tavinus/pdfScale

[7] : http://jfrohnhofen.github.io/metamaterial-mechanisms/

[8] : 'mov' on x86 : https://esoteric.codes/blog/movfuscator-and-reductio (vs. ast tree / linear compilation).

Quick way to impliment what's requested is to set up search engine/web scrape of article and find the article's doi number.

if the article has doi number, then can quickly find/filter on the requested statistics on-line and generate a personal interest ranking metric without using 'AI'. aka no peer review / subject field expert review(s), rank as 'don't display'

CrossRef[0] is a site that has related direct/indirect doi / paper statistics. note: Journals and publishers have their own platforms where you can access usage statistics for papers with DOIs. Things done prior to DOI's might require some AI/chatgpt stuff.

abstracts/synopsis section of papers and/or search engine AI generated synopsis/summary might be a quick/easy way to assess 'technical content'.

[0] : http://www.crossref.org/

---

'state of the art' side note(s):

'State of the art' kind of depends on subject matter / intended context.

Automobile industry, state of the are is good for about 1yr. Digital electronics, may be as little as 24hrs when the next patch is pushed out.

Researching what was 'state of the art' in 1850's ( aka mechanical fax[1]) bit different context than 'current now' state of the art.

[1] mechanical / digital fax : https://en.wikipedia.org/wiki/Fax

---

HN customization via browser plug-ins side notes:

One potential option would be to request modifications to a web browser plugin to be able to 'use/generate a customized metric of how to curate/filter what gets display from HN'.

example of potential canidate site for modification request if using chrome web browser : http://chromewebstore.google.com/detail/hacker-news-enhancem...

---

Misc other ways to curate HN side notes:

a) check out "Ask HN: Is there a way to customize stories on hacker news?" : https://news.ycombinator.com/item?id=40074360

b) Add-on relevant filter metrics to HN / Emacs combo : https://github.com/clarete/hackernews.el

c) Dump HN RSS to relevant filter metric script / AI,chatgpt bot and feed only what want. HN RSS : https://hnrss.github.io/

---

No report(s) on efficacy of artificial mucinex[2] on crud[1] induced spin lock and real/imaginary blue screen issues.

sheaf cohomology[3] not just for chatgpt wheeties fans!

----------------------------------------------------

[1] crud : https://cosi.ssl.berkeley.edu/the-crud/

[2] artificial mucinex has NO relation to real life mucinex product!

    artificial mucinex for pin pointing issues while staying warm in -100 F weather.
    aka serialize your feelings before your aware of what's going on.

   a) http://www.medicaldesignbriefs.com/component/content/article/36253-color-changing-bandages-sense-and-treat-bacterial-infections

   b) http//www.techbriefs.com/component/content/article/33606-shape-shifting-material-morphs-using-heat-and-light?r=52448

[3] : sheaf cohomology : http://www2.math.upenn.edu/~ghrist/preprints/networkcodingsh...

---

single fiber computer research group link : https://news.mit.edu/2025/fiber-computer-allows-apparel-to-r...

So, why not get CS with AI concentration and then demo that CS knowledge via applied applications in agriculture? (or agriculture with minor in CS related 'computer' technology)

Apply the 'CS' to reduce the demanding agriculture factors (which sounds more agriculture/mechanical related degree)