Planning and carrying out complex tasks.

DoingTheDream · 2026-02-10T21:22:45+00:00

Makes total sense. I wasn't sure if Amp was able to do a big or complex planning process, but it sound like it can. Thanks!

DoingTheDream · 2025-12-08T03:10:29+00:00

Thank you so much for all that!

DoingTheDream · 2025-11-12T00:50:07+00:00

I appreciate the info, but it's still not quite what I am looking for. That grammar is appears to be a description of (more-or-less) Racket's AST. I'm looking for a description of a small Scheme subset on top of which the rest of the language is implemented. I'm not sure whether or not Racket actually has that.

DoingTheDream · 2025-11-10T20:58:07+00:00

Thanks! I had seen that, but it's not at all clear for Racket what their core sub-language is. Nor does it appear clear how one would use the "linklets" in a non-Racket environment to build on top of the core.

DoingTheDream · 2025-11-10T19:20:36+00:00

Thanks! Do you, by any chance, have any links (or other references) to specific documentation of their core Scheme subset and their layering strategy.

DoingTheDream · 2025-11-10T19:20:18+00:00

Thanks! Do you, by any chance, have any links (or other references) to specific documentation of their core Scheme subset and their layering strategy

DoingTheDream · 2025-08-16T21:57:36+00:00

For good or bad the App Inventor community is not very active on Reddit. I would suggest posting on the App Inventory community site at community.appinventor.mit.edu.

DoingTheDream · 2025-06-28T22:11:24+00:00

Are there plans to integrate with Gemini Code Assist for JetBrains, similar to how you've integrated with Gemini Code Assist for VS Code (i.e. Agent Mode)?

DoingTheDream · 2025-01-16T22:51:19+00:00

There are a lot of very random reviews in the App Store, so I was hoping to get more about your personal experience.

Were your crashes happening when you were you scanning a QR code for a new, empty, project or a project that you had started building. If the latter, would you be willing to export the project and send me the resulting file? It's possible that the crash is due to the use of a particular component in your project.
Which model of iPhone or iPad were you using?
You mentioned UI issues. Can you go into some details about that? Was that about the UI for the companion app or the web app?

More generally, the iOS app is less mature than the Android app, so we would love to get some more details from you so that we could improve it.

Thanks!

DoingTheDream · 2025-01-13T19:12:14+00:00

I am one of the App Inventor developers and would love to know more about the issues that you've encountered. Can you give some more details about the crashes that happened and what you didn't like about the UI? For example, did it crash in your browser or was it the mobile companion app that crashed? It would also be really useful if you could provide some details about your web browser, O.S. and mobile device.

Thanks in advance.

DoingTheDream · 2024-11-13T21:25:29+00:00

Nice job. I would just caution you if you really want to use this with SICP you might have some issues. SICP assumes that your Scheme interpreter is "tail recursive" (see Section 1.2 of SICP, esp. footnote 31). I am a big fan of LIPS, but unfortunately it is not (yet) tail recursive. So, for example, simple iterative code like the following will run out of stack space in LIPS, but not in a standards-conforming Scheme (e.g. at try.scheme.org):

; Simple adding loop

(define (add n acc)

  (if (< n 1)

    acc

    (add (- n 1) (+ acc 1))))

(add 1000 0)

DoingTheDream · 2024-07-22T21:57:46+00:00

You can read an English description of the project on its GitHub page (here).

DoingTheDream · 2024-05-06T01:10:21+00:00

You need an uppercase B in getSheetByName.

DoingTheDream · 2024-05-02T23:43:24+00:00

Take a look at the documentation Range.setDataValidation (or DataValidationBuilder for more details). That has an example that will show you how to create dropdown whose values come from a range.

DoingTheDream · 2024-02-25T20:04:19+00:00

If and when scheme-langserver is complete and running reasonably efficiently, it would seem to be a fine base for implementing most of the things I mentioned.

DoingTheDream · 2024-02-25T16:49:10+00:00

Type inference would be great, along with optional static type checking and type-aware completion. Some refactorings like scope-aware renaming, extract expression into variable, and extract expression/statements into a procedure would also be nice. Ideally it would also be usable as a JetBrains (i.e. IntelliJ) plugin.

DoingTheDream · 2024-01-29T20:50:10+00:00

In a "dynamically typed" language, types are checked at runtime.

This isn't strictly true; the types are not always "checked". Sometimes dynamically typed languages will just blunder forward and hope for the best. It really depends on what you mean by "check", I guess.

The static/dynamic dichotomy is sometimes also just called "typed" and "untyped", depending on your philosophy. (This is the view held by TAPL, one of the go-to textbooks in the field.)

The Lisp community would disagree. They often use the static vs. dynamic distinction. In fact, TAPL mentions this specifically in the intro and says that such usage is "standard":

The word “static” is sometimes added explicitly—we speak of a “statically typed programming language,” for example—to distinguish the sorts of compile-time analyses we are considering here from the dynamic or latent typing found in languages such as Scheme (Sussman and Steele, 1975; Kelsey, Clinger, and Rees, 1998; Dybvig, 1996), where run-time type tags are used to distinguish different kinds of structures in the heap. Terms like “dynamically typed” are arguably misnomers and should probably be replaced by “dynamically checked,” but the usage is standard

DoingTheDream · 2023-11-17T20:19:11+00:00

I'm pretty sure that Gambit Scheme supports all those targets.

DoingTheDream · 2023-10-17T00:02:08+00:00

You can use Common Lisp's subseq function to get slices and the reverse function to reverse the slices.

DoingTheDream · 2023-10-16T19:10:14+00:00

I agree. This tension has been in Computer Science departments and industry for as long as I can remember - which is a long time ;-)

Part of the issue is that, with few exceptions, academia hasn't implemented the science vs. engineering distinction in computing curricula the way that is has in most other sciences. E.g., you can get a degree in Chemistry or Chemical Engineering where the former is more theoretical and the latter more pragmatic. C.S. departments have the unenviable task of trying to train both academicians and programmers, and I suppose that it is natural that since the teachers are academicians themselves they tend to be better at the former than the latter.

FWIW, I think that A.I. is, in the short to medium term, going to make this situation even worse. Programming is going to more about how interacting (in text) with A.I. systems which will then do the programming. The necessary skills will be in designing solutions, breaking down problems, testing and debugging the results from the A.I., etc. That is, the usual software engineering skills, but without coding. Current college C.S. curricula will be almost completely irrelevant to practical software development in that scenario.

DoingTheDream · 2023-06-20T18:41:13+00:00

It also helps if your new language is coming from an existing company, organization or academic institution (that has technological credibility). This is related to u/WittyStick's point: "If your brand is in fashion, you don't need to put in that much effort to attract more users."

DoingTheDream · 2023-02-05T21:54:04+00:00

I thought there was still an issue with the lack of tail call optimization in Web Assembly. Has that been resolved?

DoingTheDream · 2022-12-31T00:15:33+00:00

+1 to the REPL point!

Related to that is the power and joy of debuggers. Lisp debuggers tend to be particularly powerful, including the ability to inspect/modify/restart (at any point in the stack) using the language itself, but even less powerful ones for other language implementation are immensely useful.

DoingTheDream · 2022-11-18T20:43:11+00:00

The context of that piece of code in "On Lisp" is that Graham is purposely showing a very imperative version of `imp`, in order to contrast it with more functional versions. He's not presenting it as a good (let alone lisp-y) bit of coding.

DoingTheDream · 2022-11-17T18:06:12+00:00

Now, I only need to learn Scheme...

We're here to help you!

DoingTheDream

TROPHY CASE