icsa

I know plenty of people who live in Washington and work for Seattle firms without living in Seattle. Many live in much cheaper places like the Peninsula, south toward Tacoma, or up north in Snohomish county.

They work remotely or hybrid. In some cases, companies like Microsoft will transport you in a very nice coach bus - with excellent wifi so that you can work during the commute.

Have him check out:

LLM training in simple, raw C/CUDA

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

https://github.com/karpathy/llm.c

It is only 1,000 lines of easy to read C code. There is also Python reference code.

Use a model already trained on Wiki[edia using llamafile.

You can download llamafile and several models, put them on a USB drive or hard drive, them send the drive to him via DHL.

Yes. He is a software engineer in Seattle.

Check out Cleanroom development.

You don't write your own tests - ever. Moreover, you can't even execute your code.

A separate team writes the tests and certifies or denies your code, after running the tests.

How is it possible to save more than 100% ?

Check out the CMU (Carnegie Mellon University) Database Group channel on YouTube. url: https://www.youtube.com/@CMUDatabaseGroup

All of your questions (and much more) will be answered!

Another analogy

Would you rather write/read:

DIVIDE X BY 5 GIVING Y

or

y=x/5; / this would be considered "noisy" by C programmers, relative to COBOL

The first is COBOL (designed to make code easier for "normal" people to read. The second is C/Java/Python/Javascript (which looks more like the math that we learn in grade school).

k/APL/J simple moves further in the direction of the algebraic notation you already know. The difference is more operations/algorithms.

When you read the one-character symbols in K as algorithms versus characters, it makes much more sense. In addition, you can read "faster" in k than in other languages, relative to the functionality being expressed.

When I review C/Java/C++, I print out the source code and write the equivalent k code in the margin. The compression ration is typically 10-20X. Doing so speeds up my work significantly when I go back over the reviewed code.

Kx has much improved Q/k's debugging capabilities - including stack traces.

see: https://code.kx.com/q/basics/debug/

The most significant Aha! moments that I've had from using array languages (mostly k) were:

- Verbs are algorithms. Imperative and object-oriented languages require the implementation of common algorithms (e.g. find, sort, and group).

- A sequence of verbs (or adverbs) is the most direct form of composition I've ever used. Composition is easy and fluent.

- Programs are the composition of algorithms and not a collection of statements & expressions.

- The concept of domain and range treated uniformly across arrays, maps, and functions simplifies my design choices.

- Left of right evaluation means that my eyes don't have to "jump around" when reading code.

- Sending code to data is possible & preferred. Most of my significant k projects fit in a network MTU (i.e. 1540 bytes), not including comments.

K bonus:

- Views (i.e. dependencies) can implement functional relationships directly.

- Hot code (via the interpreter) loading makes "forever" applications possible.

You are not alone. I did a project to upgrade "sort of XML" to standard XML. Your example content gave me flashback shivers.

A craftsmen has different tools for different purposes.

E.g. Text editor Hex editor Source code editor

Yep.

Q: How big is the 90th percentile text file?

64KB? That text file fits in some some level of cache and not RAM. An array is just fine most of the time.

Use a different purpose-built editor for those multi-GB text files.

Buy-in from management (or the funder) is key. They need to understand that more than 50% of the schedule may be taken by the documentation process.

This is not Agile nor Scrum, by any means.

Answering the hard questions will be agonizing.

E.g. - I once spent 3 hours with a UI/UX dev/designer working out the state machine for the key feature of a commercial product. She was frustrated working through the process - i.e. "Can't we just start with something!". And we were literally perspiring from thinking so hard. I explained that multiple versions of the state machine running at the same time was a bad idea. We persevered and that piece of code never had to be modified through the product lifecycle.

Prototyping features to vet user acceptance is quite common and recommended. Pick a prototyping language unsuitable for production ;) That way prototypes can't "accidentally" be turned into production software.

Consider reading "Toward Zero-Defect Programming" (1st Edition) by Allan M. Stavely.

When possible (i.e. consent from management), every time (i.e. 10) I have used this approach, I was able to deliver zero-defect software, on time, and within the budget. This kind of documentation is literally the hardest work I've ever done in software. Eliminating ambiguity and vagueness is not for the faint of heart but the result is quite satisfying.

See Aaron Hsu's excellent descriptions (using APL):

https://www.youtube.com/watch?v=hzPd3umu78g https://www.youtube.com/watch?v=X5_5MtOYNos

> A new cosmo_dlopen() function is now provided that's good enough to load nontrivial dynamic libraries on all platforms except OpenBSD.

Read my mind...

I worked on a very high-performing software development team for several years. We never talked to each other. We only communicated via email.

I lived on the West coast of the United States. The team lead livid in New York City, The other two team members live in Russia.

Thoughts from a Stanford CS graduate:

https://www.youtube.com/watch?v=4SiFgB1lGxw

> lisp ocaml haskell

Covers all of the major programming languages in a deep way.

> interpreters (SICP), compilers, type systems, transaction processing, effect systems, FRP, concurrency

These subjects are the core of almost any system that you'll encounter, in practice - academic or industrial.

You're weird but not alone.

I can't write an app or web site to save my life.

However, if you need to analyze 100MM lines of code with bespoke methods, speed up a mature system built by CS PhDs by 10X, do customer segmentation from micro to macro on billions of transactions - no problem.

Loops are a general purpose device that must be specialized for a given use case - e.g. map, reduce, fold et cetera. Programmers often get the details wrong when implementing such use cases. In a functional program, each use case is named and generally available (in a correct form) via a library or built-in operation.

These days, I's put my money on zig cc. I.E. zig cc -Os or zig cc -O3

Extendible hashing or Minimal perfect hashing

Long COVID is an important consideration. I'm seeing people in their 20s and 30s whose lives are being turned upside down with Long COVID. And yes, children are being affected directly as well - esp. gastro-intestinal issues.

Find a company culture that does have meeting-itis.

Let people know that you don't respond to personal communications nor interruptions during working hours on weekdays. Keep work meetings to 3 hours per day or less and only during working hours. Give yourself at least two 1 hour blocks per day for deep work. You'll have plenty of time to learn new technologies.

Because most of the essential concepts in computer science were developed by the early 70s. In addition, the concepts were developed in an era of scarce computing resources. Acess to relatively unlimited resources does not foster creativity.

The phrase "Necessity is the mother of invention." comes to mind.

Look up the youtube demo videos (from the 1960s) of:

* Sketchpad

* The Mother of All Demos

* Grail

The ability to read in more than one language + curiosity.