LabMechanic

LLMs don't necessarily need to think to be useful. Having a simple minimal working example from an API you're trying to grok is helpful, as long as it's error-free and not redundant.

However, given the availability of LLMs, how would you justify the expense of hiring junior developers fresh out of school?

Check Microsoft.com or Google.com's career pages as an example (you will also see something similar going on within mid-sized companies), do you find any jobs for entry level applicants? Are those entry level jobs offered mostly in India or Eastern Europe?

So tell me, how is the ability to think helpful for an entry level applicant, when HR departments won't hire you because you lack “2+ years of non-internship C++ experience” for an entry-level position?

My point: being able to think is of course fine, but HR departments require you to do back and front flips, speak perfect reverse Mandarin Chinese and have 2+ years of non-internship experience in C++ on top of that. Being able to think won't justify the expense of hiring a junior dev fresh out of school in a high-income country. (At least this is my impression of the current job market.)

PS: So, I just finished school last year, and I'm still on the hunt for a job. It seems like a lot of companies in wealthy countries are holding off on hiring newbies like me. I get why they're doing it (e.g., inflation, interest rates), but it's really frustrating when you're the one affected.

I mean, how are we supposed to get experience if no one's willing to give us a shot, right? It's a tough spot to be in. Then the LLMs (even if they cannot think), they still bring value and accelerate development (with a potentially lower headcount). Seniors will be fine without us juniors given the prevalence of LLMs and high inflation environment (which makes companies risk-averse and very picky).

The question remains, what is "value" (i.e., money) that we can use to exchange for other things that bring us "value" (i.e., money)? Water preparation, catching fish and making fire can bring “value” in forms of nutritional energy and bodily satisfaction.

However, our Western governments require us to have permits to catch fish, make fire. Yet, employers do not want us entry levels working at their companies. In California, they are moving the "goalpost" with the homeless people (not few are older folk where some of them went out of luck).

So tell me, is this “consumer economy” still a thing?

I visit job search sites and select the “entry level” filter. Then, I read requirements such as “2+ years (non-internship) experience in C++”, “5 years of professional experience in the game industry”, and “excellent C++ skills”. Furthermore, there are requirements like “Fluent in speaking reverse Mandarin Chinese” and “being able to perform perfect back and front flips on command”. The latter two are, of course, exaggerations, but I couldn't help joking about them to alleviate the dire circumstances not only I find myself in, but also others in my circles.

I know individuals who attended top computer science universities, earned master's degrees, yet they still struggle to find a job. The missing element in such conversations is that recent graduates often lack the required expertise that HR departments demand. Companies or their HR departments have become extremely selective and require multiple interview rounds before considering employment. Alternatively, companies hire student workers because they are cheaper, or they outsource hiring to countries like India, Eastern Europe, or Turkey, pausing hiring for entry-level applicants in high-income countries.

However, some governments claim a “shortage of skilled labor especially in the IT sector,” while individuals with computer science degrees find themselves unemployed in these “uncertain times”. Experienced individuals may manage to stay afloat, but those without experience, such as recent graduates like myself, are deemed less valuable. This is partly due to the prevalence of Large Language Models (LLMs), which I refer to as “Google search on steroids”.

Have you heard of “bullshit jobs”? If so, I suspect that many positions are actually insignificant. As a student worker, I co-developed an audio editing application (C++17, Qt 5). To be honest, there was nothing in it that hadn't already been solved. Would you argue that a “level meter”, “equalizer”, or “JSON parser” are things that need to be reinvented despite the availability of MIT-licensed libraries?

Rather, these jobs appear to be a form of “collective busywork”. Nevertheless, the fortunate few engaged in such “busywork” earn significant sums despite not contributing much. What kind of economy is this, where one can thrive without generating actual value (e.g., innovation, non-copy paste work)?

A “consumer-oriented economy”, huh? We need consumers, yet we cannot drive up consumption, because we collectively play a game of hot potato until someone solves all the world's woes for us.

My personal suggestion:

Make sure you are able to set pixels and create audio samples (sine function sampled over a discrete time steps). Also make sure to store the results as PPM P3 (very simple text-based image format) and WAV. Some inspiration form Wellons: https://nullprogram.com/blog/2017/11/03/

Then you can implement a ray tracer, a rasterizer or audio generator.

Other ideas:

  - implement your simple neural network learning XOR
  - implement your hash table or your version of std::unordered_map (array + 
    hash function + tombstones)
  - arena allocator
  - dynamic array or your version of std::vector
  - a circular/ring buffer (that you can also use as a queue/stack)

Who knows what the future will bring (will we ever get AGI)?

Needless to say, fundamentals, that is, math (geometry, algebra, and calculus) and physics (mechanics, electromagnetism, thermodynamics).

Some basic algorithms/techniques such as backpropagation, triangle ray tracing and rasterization, and some fundamental awareness that you can compute anything given 5-6 instructions (Turing completeness). Knowing how to program in a language like Python might suffice.

Then there are skills that are essential to maintain your life, such as fire making, fishing, and water filtration. You need to get energy someway.

See also Maslow's pyramid.

You forgot, fire making, water filtration (essential) and fishing (protein, fat, vitamins). How can you do all the stuff without energy? Are you running on sunlight, or do you do nuclear fission inside your body?

Usually not. For me, it's an “autonomous search engine on steroids, i.e., its huge dataset”. (I.e., it's just another tool you use.)

Before LLMs, you would cobble a bunch of disjoint information via a search engine like Google. Now, LLMs do this for you, and it certainly helps me to get a lot quicker with using libraries or APIs I am not familiar with (e.g., PyGame, Flask, Django). However, you might find that code from the LLM might need some fixing (subtle bugs or redundancies) or a better use of resources.

The other issue is the LLM's dataset bias towards the most used technologies or concepts. So you might have a hard time with an LLM trying to make Clojure/Racket code or telling the LLM to specifically do the point-in-triangle test with the wedge product only.

Hence, there is still some leeway or reason to use your thing between the ears.

You might as well ask: Are you referencing Stack Overflow or the Microsoft Developer Reference (e.g., in your developer notes/comments)?

My answer: usually, yes.

You can consider using MinUnit and Clang-Tidy together with Clang-Format as well, further, for C it should be something more like this:

    CC = clang
    CFLAGS = -g -std=c2x -Weverything -fsanitize=undefined,address
    
    all: app.exe
    

    app.exe: src/main.c
      $(CC) $(CFLAGS) src/main.c


  clean:
    rm -rf /build

See my comment here with an example of an NMAKE Makefile. Consider:

https://nullprogram.com/blog/2017/08/20/

Here's a simple NMAKE Makefile using MSVC to compile a Win32 application on Windows 11:

  CC = cl.exe
  LD = link.exe
  CFLAGS =  /Od /Zi /FAsu /std:c17 /permissive- /W4 /WX
  LDFLAGS = /DEBUG /MACHINE:X64 /ENTRY:wWinMainCRTStartup /SUBSYSTEM:WINDOWS
  LDLIBS = user32.lib gdi32.lib
  PREFIX = ../src/

  all: app.exe

  app.exe: app.obj
  $(LD) $(LDFLAGS) /OUT:app.exe app.obj $(LDLIBS)

  app.obj: $(PREFIX)app.c
  $(CC) /c $(CFLAGS) $(PREFIX)app.c

  clean:
   rmdir /q /s build

Use MinUnit.h

https://jera.com/techinfo/jtns/jtn002

Consider using Clang-Tidy with

  `-*,cert-*`

(Which disables all default options, and checks your code according to the Secure coding standard (CERT) ruleset.)

Use Clang-Format as well. If you use Clang, consider `-Weverything -fsanitize=address,undefined` and disable options that you do not need. Consider using NMake or Make (or just write a simple script to automate building the stuff).

Here's a Google-esque style guide for C:

https://gist.github.com/davidzchen/9187878

At least, this is my approach.

What do you think about money and income? If people in the Western world get older, lose jobs, earn less money, and have fewer kids, who will buy those kinds of products? Maybe people in “third-world” countries (who might have enough young people)? How can those young people exchange their labor for money? Will an unskilled worker have enough wealth to buy such products? What about governments? Will they make taxation higher (e.g., less wealth for you)?

At least from my experience and from the suggestions from Nassim Taleb (e.g., past events/data != future outcome/data), we cannot reliably predict the future.

The only thing that is constant is, as someone a long time argued, is “change”. Arguably, basic needs, and with that I mean existential needs, seem to be universal for most lifeforms: water, forms of energy (i.e., food, warmth), and the ability to maintain your system.

If something very bad hits the fan (no agriculture, no public farmland), you and me probably need to first learn how to make fire, how to purify water and how to catch fish. Fishing without permission could lead you to jail, but in tough situations, the legal stuff might be not your main concern. How much does it cost to get a permission? Can you afford it if you're homeless and no one is helping or giving you a job, a shelter? How are you going to get taxed and pay your government your state employees (e.g., police)? Who will then pay police to enforce laws? Or who will protect your basic constitutional rights, if you cannot pay taxes to finance a judge? Or, more extremely, what if a lot of people will be out of a job overnight? What will the government and state people do then without this transaction? So, there's a lot of what ifs… We aren't there yet.

In other words: how can you take part in a fair society if there are no jobs available, especially if you're old, unlucky, or your skills aren't as useful anymore because of LLMs or possibly AGI? Which means society does not need you, and perhaps would like to get rid of you.

The question is, will wealth (the ability to make transactions) still be relevant if AGI becomes a reality? What kind of transactions can you make? Buy AGI systems powerful enough to fulfil all kinds of labor needs, buy farmland, buy wells or sources of clean water? However, why should this be possible if some of us live in a democracy, even if there is a great influence from those with wealth?

Since I tend to be negative about things (i.e., I am biased), it's hard to say for sure what will happen. Further, there might be a lot of things I have not considered (tunnel vision).

PS: the dollar has no intrinsic value, we give value to it. So, I do not know what wealth means, if there is significantly less need for human labor. Ultimately, if some of us can have “free slaves” (i.e., robots), then some of us arguably do not need to have wealth (the ability to make transactions). Only raw power/dominance and luck.

Somewhat similar to the dark ages with its aristocrats ruling over us.

Creating AGI needs powerful computers, which are costly. Independence from humans, like workers in chip factories, requires bootstrapping[1]. This leads to a scenario where a subset of humans serves their bosses, and bosses serve shareholders until AGI takes over. Those with money hold power, and if we aren't good “slaves” robots might take over. There's a chance of using prison labor, especially with the ease of getting jailed in the US for minor offenses. A cynic might say: why not change laws to make it easier to jail people? Might solve homelessness, and we get free labor that way. Rising homelessness is likely. The only option for us “plebs” is to learn basic survival skills like making fire, catching fish, and purifying water and possibly fight each other so that those who rule over us be at ease:

“When two people quarrel, a third rejoices.”

We might have a “democracy” on paper, but it is clear to me that the people can influence politics with great leverage, if they have enough wealth at their disposal:

“Despite the seemingly strong empirical support in previous studies for theories of majoritarian democracy, our analyses suggest that majorities of the American public actually have little influence over the policies our government adopts. Americans do enjoy many features central to democratic governance, such as regular elections, freedom of speech and association, and a widespread (if still contested) franchise. But we believe that if policymaking is dominated by powerful business organizations and a small number of affluent Americans, then America’s claims to being a democratic society are seriously threatened.”[2]

Keep in mind though, we cannot predict the future, it might be worse, it might be better, it might be something we cannot even imagine (see Nassim Taleb). Further, I seem to have pessimistic tendencies (biases), so keep that in mind too. So, I hope that my pessimism is just futile and does not hold any water (not even a drop).

Reference:

1. “In general, bootstrapping usually refers to a self-starting process that is supposed to continue or grow without external input.” [Source](https://en.wikipedia.org/wiki/Bootstrapping)

2. https://www.cambridge.org/core/journals/perspectives-on-poli...

I find Clojure, Racket and F# to be nice, yet, it being nice does not help to pay your bills (most likely judging by the job openings you see at those job search sites). But it might help you to enjoy programming again. There are Clojure shops out there, but look at, Indeed, how many Clojure positions vs. how many regular language positions are out there?

What concrete advantages does OP gain from solving a problem in Rust? If you're considering creating a language binding in Rust, you can't easily bypass C, the predominant language for operating systems, and may end up using “unsafe” anyway. While you can designate certain parts as safe and others as unsafe, the real question is: what tangible benefit does this bring to you? Is safety truly a crucial factor? Various tools like Clang-Tidy and cppcheck, as well as the SEI CERT C Coding Standard, address safety concerns.

On the flip side, Rust has great error messages and boasts a robust package manager, “cargo” (more convenient than say CMake) but lacks libraries such as STB, Catch2, nlohmann::json, and DirectX Math, OpenGL, …

Although there are bindings to libraries for DirectX Math created by others, the question remains: are they genuinely production-ready? C and C++ have a long history, they are different languages, but they are arguably orthogonal. Not completely different.

I would say: do not focus on languages, more on solving problems. That means, learn fundamental subjects well (geometry, linear algebra, calculus, differential equations). If people like Karpathy and Jensen are right, then being very good at a particular programming language might not have much of an importance.

https://karpathy.medium.com/software-2-0-a64152b37c35

SEEKING PROJECTS:

Technologies: C/C++, Python, JavaScript, Rust, Scala 3, Clojure, Racket, Qt 5, SDL2, Windows API, DirectX Math, Play, Vue.js

Projects: I did write basic software rasterizers and ray tracers (in C/C++, Rust, Python, JavaScript) and a neural network learning XOR from scratch in Python. I haven't uploaded many of my projects on GitHub yet, but here is a small sample:

https://privatebin.net/?ae5a97996cd17be6#7Ps9FAqTCQYPGMmj1rY...

I am sufficiently open and curious enough to any kind of project.

E-Mail: see my about. ;)

Thank you!

Location: Europe

Remote: Yes

Willing to relocate: Yes

Technologies: C/C++, Python, JavaScript, Rust, Scala 3, Racket, Clojure, Linux, Git, Make, CMake, Clang-Tidy, Clang-Format, Catch2, Windows API, DirectX Math, SDL2, Qt, Play, Vue.js

Résumé/CV: https://drive.google.com/file/d/1mT6TmIjZO_dCS6q4qTP-Zikx3bb...

Email: see my about or resume.

---

Hello, I'm a recent computer science (B.Sc.) graduate eager to embark on my first role as a software developer. I bring a diverse skill set with experience in several key technologies and a solid grasp of mathematics (linear algebra, “3D math”, calculus). I am open to both long-term positions and contract work, ready to contribute my skills and enthusiasm.

Nassim Taleb also suggests to not predict the future from past events. Why? Because we are not almighty and all-knowing, but we seem to collectively pretend that we are.

Some people (Munger? Buffet?) believe The Coca-Cola Company will continue to exist, because it existed for that long (Lindy effect), so it must continue to exist. Why “must”? The problem is right here, you cannot reliably predict the future. Who knows what will happen by 2060?

Therefore, things like Kondratiev waves might be a new form of modern coffee cup reading.

What a coincidence, I was thinking of the same concept pictorially reading the comment you replied to, but I did not remember its name.

Panopticon it is:

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

Generally, there is plenty of reasons to be worried:

  - Firmware-wise (e.g., Intel Management Engine, Coreboot, Libreboot, system on a chip)
  - Hardware-wise (i.e., Von Neumann architecture - Code + Data)
  - Operating System-wise
    (e.g., 0-click exploits, remote code execution to manipulate the CPU's instruction pointer,
     stack overflow, Pegasus)
  - Facility-wise (e.g., electromagnetic waves, cell towers, Faraday cloth)
  - You (making mistakes)

What you can ultimately do is: rely on randomness (e.g., rolling casino-grade dice), Diceware, one-time pad, no computers of any kind. Further, hope that time traveling backwards remains impossible. Otherwise officers will travel back in time and can see what you wrote (e.g., unencrypted message) back then.

If you need some electronics go with analogue electronic devices. Or, make your own computer systems from scratch with transistors etc.:

jdh, I built my own computer. by hand., https://youtu.be/vaGZapAGvwM?si=lGQuskkFxZ7FHe1h

I have three options for you, along with my two cents on each:

1) *Bitwarden:*

I am no longer using Bitwarden since they can delete your account at any time for any reason[5].

2) *KeePassXC:*

For KeePassXC, you need to store your "Passwords.kdbx" (~16 kB) database file somewhere and remember a master password.

3) *Spectre (https://spectre.app/)\\\*

I haven't tried it yet; however, Spectre calculates your password each time you need it. All you need is a name (e.g., your full name), your master password (see Diceware[1]), and the site name, from which Spectre algorithmically calculates your password. If you need to change a site's password, iterate the counter and calculate a new password.

It works offline and is open source. Here's a web app version that runs locally:

[Spectre Web App](https://spectre.pw/)

*Bonus: One-Time Pad + (Layman-ish) Physics:*

There are plenty of reasons to be paranoid[2]:

  - Firmware-wise (e.g., Intel Management Engine, Coreboot, Libreboot, system on a chip)
  - Hardware-wise (i.e., Von Neumann architecture - Code + Data)
  - Operating System-wise
    (e.g., 0-click exploits, remote code execution to manipulate the CPU's instruction pointer,
     stack overflow, Pegasus)
  - Facility-wise (e.g., electromagnetic waves, cell towers, Faraday cloth)
  - You (making mistakes)

Given the above, I would first base everything on "true"[A] randomness (see random.org or roll casino-grade dice). "True" randomness is essentially: "every outcome has the same probability." As long as backward time traveling remains impossible, I would abstain from computers and simply follow the One-Time Pad protocol with a pen and paper, among other things.

  Message: Hello -> ASCII -> Binary

  Key: 5EYES (keep this private, must be random)

  Cipher: <Message in binary format> XOR <Key in binary format> -> convert back to ASCII

The above is just one (i.e., XOR) out of many ways to follow the one-time pad protocol. For 128 characters, you need a random number from 0 to 127. However, you need to ensure that each number has the same probability to show up. Perhaps there is a way to encode or "rename" the numbers from 0 to 127 with a string of digits 1, 2, 3, 4, 5, 6 so that you can roll a die multiple times in a row to randomly get a number between 0 to 127 (see Diceware[1]). One-time pad might be good to encrypt your master password.

*References:*

  1. Diceware, [Wikipedia](https://en.wikipedia.org/wiki/Diceware)
  2. CS155 - Computer and Network Security,
     [Stanford](https://crypto.stanford.edu/cs155old/cs155-spring18/syllabus.html)
  3. [One-time pad - Wikipedia](https://en.wikipedia.org/wiki/One-time_pad)

  4. Animated Explanation of the one-time pad, https://www.youtube.com/watch?v=QVV_bUxxiZ8

  5. https://tosdr.org/en/service/1348

*Notes:*

  A) If you assume determinism (because our current "collective bias" leads us that way),
     then the quote marks are okay; if not, then not.

  Personally, everything seems to be based on assumptions or beliefs anyway (your existence, math, ...),
  so I go by "ignorance is bliss."

Hmm... wouldn't you agree that a formal (relatively accurate language) such as math is easier to get right than an non-accurate human language?

The non-popular or non-widespread aspect of a "prompt" (e.g., "derive the geometric product given axioms/definitions ...") should be understood as a data point that it might lack reasoning skills. As it seemingly parrots what most of its dataset "says". For more details, check my other past comments. Calling such LLMs "AI" seems to be sensationalism at work.

A popular user here on HN also had a similar revelation or sentiment. We will see...

Seems like you are moving the goalpost (i.e., don't expect it to derive a theorem given a set of definitions and axioms from a non-widespread field). It should, in fact, derive any formula given a set of axioms and definitions, but we can't be sure whether randomness fooled us (again). If an LLM can indeed derive any theorem given axioms/definitions, even if we make up a field, then at this point it might not matter:

Ignorance is bliss.

You might see them both "being very, very similar", but that does not mean that it is.

I mentioned it countless times already, but it gets tiresome to repeat myself. Just ask your "AI", capable of "thought", a question (e.g., derive something given a set of axioms and definitions) from a non-widespread field (e.g., perspective geometry, Clifford algebra).

Then you might also arrive at the conclusion that it is a hyped up "Google search results mixer and matcher".

Who knows, but until it can fool me by randomness (like Nassim Taleb suggests), i.e., deriving something given a set of axioms and definitions (from a non-widespread domain), then I might join your "ignorance is bliss" argument.

Also, hype is good for the stock market, so keep hyping it up? At the end, Elon Musk success seems to stem from hype and sensationalism. CNN (i.e., "breaking news" everywhere) has financial success due to sensationalism and hype, so hype is good, I guess?

I am doomed to repeat myself, but I mentioned it countless times in the past and I also mentioned it here: Try asking it to derive something given a set of definitions and axioms from a non-widespread domain (e.g., Clifford algebra, perspective geometry). Then you might see that it parrots what the majority of its dataset says. It is essentially similar to Google, but you don't mix and match the search results, the LLM or the "AI" does.

Yep, or somehow they make it apparent that they indeed "parrot" stuff they had in their large dataset. See my past comments for details. Fooled by randomness? (See Nassim Nicholas Taleb)

Okay, I mentioned this in some of my past comments, but try this:

Ask your "AI" something about a non-popular domain (e.g., Clifford algebra) or even ask it to derive something (e.g., the geometric product) given some axioms and definitions.

Mathematics is precise as it gets, yet it failed to derive the geometric product given a set of axioms (e.g., distributive property) and definitions. Ask it to derive a theorem from perspective geometry.

Or, try something else that is not so popular or widespread (something outside of math), I suspect, that it also does a poor job deriving things from principles (axioms, definitions, theorems).