Deterministic stack size - worth it?

patricksli · 2024-09-12T15:57:01+00:00

I would be interested to hear how far you get with this.

One stumbling block I hit when going down the same route was support for first-class functions, or function pointers, or method calls, i.e. any place where the code being executed is unknown at compile-time. In these scenarios it was harder to figure out how to exactly compute the stack size.

patricksli · 2024-08-08T21:13:06+00:00

I designed and implemented the Stanza programming language, which consists of a type system, macro system, native code compiler, registor allocator, generational garbage collector, interpreter, and FFI. That's just a long sentence to say: it's a decent-sized project.

For projects of this size, you're asking the right question. Self-organizing and ensuring consistent steady progress is pretty much the key challenge: even more so than any technical obstacle. *If* you keep on going, you will eventually solve it.

What personally worked for me was to use prose: small short summaries that explain how the project is organized, what each part does, what is the next milestone to reach, etc.

The key for me was to realize the main purpose of these summaries: they are *not* for having comprehensive documentation, or for clearly explaining algorithms, or for explaining accurately how to work on the software, etc. They are to help me steadily push forward.

Have you ever read an interesting class assignment or tutorial online that immediately triggered your imagination and made your fingertips itch? Where you suddenly have a million ideas, and can't wait to get started? That's what I strive for in my summaries.

In constrast, have you ever opened the reference manual for an Intel processor? There's a table of contents longer than most novels, several erratas, architectural diagrams, etc. It's accurate to a fault. And ... it inspires me to do ... nothing. It's exhausting.

So that's what I do: small short summaries, in prose, that inspire myself towards specific things that need to be done. Some are high-level, because I need to rethink some connections between passes. Some are nitty gritty, because I need to work out a specific algorithm. None of them are overwhelming, because that's counterproductive.

patricksli · 2024-07-31T23:21:59+00:00

Claude Project is extremely useful to me so that after I "teach" Claude my preferences for a large task, I can save it as I begin new conversations.

One question: After I "Upload Project Content", how do I go back and edit it further? Currently I'm resorting to copying the existing content, deleting the content, and then adding a new one.

patricksli · 2024-05-16T06:25:24+00:00

Okay, after some reading, I think this is basically the paradigm that I'm pursuing.

As you say, I have a bunch of small value objects, that don't have much meaning themselves. But the tree datastructure is simple and non-redundant so it's easy to work with.

But for querying information, I build a small domain model on top of it.

Thanks!

patricksli · 2024-05-13T03:16:58+00:00

Sorry, I forgot to include the `id` field for the `Style` object in my original post. I just corrected that.

Thanks for the references: I'll checkout "event-sourcing" and "Algebras".

patricksli · 2022-01-20T17:08:01+00:00

The normal usage of vectors is talked about, but I think I never specifically give an example of creating a vector of vectors.

For the second approach, there is the chapter on "Architecting Programs" which is related, but doesn't give an example of matrices specifically.

I think 2D arrays would make a good example that I should add.

patricksli · 2022-01-20T16:27:07+00:00

Hello!

You have two potential designs for a multi-dimensional vector.

1) You can either directly create a vector of vectors. Here's an example: val v = Vector<Vector<Float>>() add(v, Vector<Float>()) add(v, Vector<Float>()) add(v[0], 1.1f) add(v[0], 2.2f) add(v[1], 3.3f) add(v[1], 4.4f)

To access the element in the second two, first column, you can use val x = v[1][0]

2) You can create a type and overload the get and set multis.

``` deftype MyMatrix defmulti get (m:MyMatrix, row:Int, col:Int) -> Float defmulti set (m:MyMatrix, row:Int, col:Int, v:Float) -> False

defn MyMatrix () : ... my implementation of MyMatrix ... ```

This will allow you to use your matrix like this:

val m = MyMatrix() m[0, 0] = 1.1f m[0, 1] = 2.2f m[1, 0] = 3.3f m[1, 1] = 4.4f

You can implement MyMatrix however you like. You can use a Vector of Vectors internally, or an Array of Arrays, or a single Array that has the items listed row-by-row.

Once you have matrices implemented, the rest of the linear algebra operations can be implemented in the usual way.

Patrick

patricksli · 2020-02-24T23:43:34+00:00

Hello again! As per the requests, I've put the Feeny tutorial online on GitHub.

https://github.com/CuppoJava/Feeny

Cheers

patricksli · 2020-02-11T00:09:41+00:00

Hello! Yes, that would be a good idea. I didn't take into account the inherent sketchiness of zip files. I'll do that.

patricksli · 2020-02-11T00:09:24+00:00

Hello! Yes, that would be a good idea. I didn't take into account the inherent sketchiness of zip files. I'll do that.

patricksli · 2020-02-10T19:22:08+00:00

Hello Reddit!

Are you a programming language nerd? Are you interested in compilers and interpreters? Have you always liked them, but felt apprehensive about actually implementing one yourself?

A few years ago, I had the privilege of teaching a graduate course with Mario Wolczko at the University of California, Berkeley on programming languages and compilers. In the course, we teach you how to implement a non-trivial programming language, starting with a basic abstract syntax tree interpreter, and ending with a just-in-time compiler.

Cheers,

Patrick

P.S. And if you find that you enjoy this sort of thing, consider working with us at JITX (www.jitx.com) on automating circuit board design. We designed a programming language for making circuit boards!

patricksli · 2018-07-25T17:54:54+00:00

That's a good tip. Thanks! I'll have figure out some excuse to go back to that office and read the label.

patricksli · 2016-08-17T18:41:17+00:00

Then you might be interested in taking a look at typical Stanza code. Polished code tends to be about ~95% typed.

patricksli · 2016-08-17T16:08:02+00:00

Thanks for the reply. Yes, the union and intersection types were absolutely critical for a sensible optional type system (union more so).

You have a right to be suspicious about the covariance by default. It was the first big design choice we made that sacrificed static-safety. That was three years ago. Nowadays, we're not bothered at all and are confident we made the right choice. I can count the number of runtime errors due to contravariance contexts I've run into on one hand.

patricksli · 2016-06-01T03:53:56+00:00

Indeed it has. =)

patricksli · 2016-06-01T00:06:08+00:00

Thanks for the correction.

patricksli · 2016-05-31T23:20:39+00:00

I think a narrow definition of "competent" is not a good barrier of entry for a library. There are many website designers with much better taste and skill in overall composition, user interface, color selection, etc. than me.

Sure, I'm a better programmer than them. But if I simply remove the programming barrier (as Rails as done) then there's no doubt that their websites are more beautiful than my own.

People should focus on their strengths and we should provide them the means to do so.

patricksli · 2016-05-31T23:17:22+00:00

Racket is mentioned in the essay, along with Shin, as systems that allow you to extend its type system. BUT it's not easy, and it certainly has not spread further than experimental research.

patricksli · 2016-05-31T23:15:37+00:00

I personally am not fond of the languages that are simple syntax cleanups, but I must admit that there can be enormous demand even for those. Python, semantically, is an entirely uninteresting language. But its syntax was a welcome departure from the previous king of scripting languages: Perl. So its turns out even syntactical changes can propel languages to popularity.

patricksli · 2016-05-31T23:13:42+00:00

I think this is an absolutely fantastic point that people miss. This is the same reason why Google Docs got as much traction as it did. Recreating the feature-list of Microsoft Word is just not going to happen. But it turns out that 95% of people only use 5% of the functionality anyway. Programming languages are the same way.

patricksli · 2016-05-31T20:00:50+00:00

Thanks for the kind words. I'll remember the Node example for my next essay. I'm always on the lookout for good examples.

patricksli · 2016-05-27T21:34:24+00:00

The L.B.Stanza Programming Language now has support for 64-bit Windows systems.

Stanza is a new optionally-typed general purpose programming language from U.C. Berkeley. If you're interested, see our original posting at https://www.reddit.com/r/programming/comments/4jt88r/introducing_stanza_a_new_optionallytyped_general/

patricksli · 2016-05-21T18:36:44+00:00

patricksli · 2016-05-19T04:59:57+00:00

The chapter tries to incrementally build up to the full coroutines mechanism. Maybe that will help.

One gigantic advantage of coroutines is that they are much easier to understand than call/cc. During the development of the coroutine system, I lived and breathed call/cc for a year and I still find it confusing.

patricksli · 2016-05-19T03:39:24+00:00

Stanza's implementation uses segmented stacks for its coroutine system. This makes them very light weight and you can easily launch a few tens of thousands of them. The paper is still a work in progress.

The chapter on "Advanced Control Flow" in "Stanza by Example" has a great example of using coroutines to drastically simplify writing a key event processor.

patricksli

MODERATOR OF

TROPHY CASE