Excel (all spreadsheet applications) are an integrated environment for non linear functional programming with flexible data structures, where you can see all memory and data at the same time. It’s a marvel.

Do you mean lack of quality native applications?

I wrote some sample code in this answer.

Depending on the language exceptions are used in many different ways. Some use it liberally for all kinds of error handling.

A good feature of Exceptions is you can throw them all the way up the stack and handle them there, giving you loose coupling between the code that calls the dangerous code and the one that catches it.

Exceptions have a big runtime overhead, so using them for normal control flow and error handling can be a bit meh.

Using return types can be great, if the language has good support for. For example swift enums are nice for this.

enum ResultError  {
  case noAnswer;
  case couldNotAsk;
  case timeOut
}

enum Result {
  case answer: String;
  case error: ResultError
}

func ask(){
  let myResult = askQuestion(“Are return types useful?”);
  switch myResult {
    case answer: 
      print(answer);
    case error:
       handleError(error);
  }
}

func handleError(error: ResultError) {
  switch ResultError {
    case noAnswer:
      print(“Received no answer”);
    case couldNot:
      …
  }

}

Using enums and switch means the compiler ensures you handle all errors in a place you expect.

A friend has had good results using AIDD as an agent framework. It’s basically a built in project/product/scrum master that creates tickets and with that constraints.

Have you tried something like this?

The available libraries, operating system, and hardware platform pay a bigger role than the programming language. Often the choice of language follows the tool chain and frameworks that fit with the intended program.

And love reading ten pages of Java stack trace.

Reasoning about memory use is kind of hard though.

For LLM generated code, it can also take a whole to read and understand. When I write code myself, I understand the intention, architecture, and so on. Machine written code is very different. I need to understand how it works. There’s often extraneous stuff in there or weird patterns.

Write a program that reads or writes a simple binary file format. I recommend midi, TIFF, BMP.

For example write a generator for fractal images.

Complexity is inherent an unavoidable.

C++ is a great language it you refrain from using 70% of its features.

Never use numbers when calculating dates. Use the data formats and constants the calendar library provides.

When learning a new human language, it’s good practice to also learn sentences and practice speaking and writing, not just rote vocabulary memorization.

When learning a new human language, it’s good practice to also learn sentences and practice speaking and writing, not just rote vocabulary memorization.

The waste and corruption in private industry is mind bogglingly huge compared to the public sector.

ADB was superior.

Start with designing a physical card or board game. Play test it until it’s fun.

For artwork practice drawing on paper.

For writing write stories and dialogue.

Make or choose some music.

Use the above to make a video.

No programming required.

Java has been running serious server software since the mid 1990s. Think WebObjects running on Solaris. Lots of business stuff with big databases still run infrastructure like that.

Java still has the big advantage of being machine agnostic. No need to recompile for ARM or Intel.

Early Swift was very slow to compile and start. The debugger was nonfunctional.

Otherwise it was pretty usable. Especially since it got to leverage the huge libraries written for Objective-C.

Which meant it lacked some basic collection types. A Swift native Set was introduced with Swift 3 IIRC. Before that you had to bridge back and forth between Swift and Objective-C. Sometimes leading to unexpected behavior at runtime.

In Objective-C if an object reference was nil, you could send it messages (call methods) without a problem. Swift however did away with this. Optionals had to be explicitly unwrapped. So if the annotations weren’t correct, Swift code would crash at runtime where Objective-C would have been fine. Lots of bugs related to that existed.

Swift peaked around version 4. Since then, they have been adding kitchen sink features and lots of complexity to feel smart.

I still would have preferred an Objective-C 3.0. Chris Lattner was a C++ guy and never really understood Objective-C culture and strengths.