ESP32Forth https://esp32forth.appspot.com (https://github.com/flagxor/ueforth) written in very readable C easy porting, easy access to Arduino libraries, easy to get running ESP-IDF Installed VSCode extension (https://github.com/espressif/vscode-esp-idf-extension) User Guide https://documentation.espressif.com/esp-idf/en/latest/esp32/index.html Arduino ESP32 https://documentation.espressif.com/arduino-esp32/en/latest/index.html (https://github.com/espressif/arduino-esp32) Adafruit Feather ESP32 WROOM https://github.com/espressif/arduino-esp32/tree/master Xtensa Register Windowing http://cholla.mmto.org/esp8266/xtensa.html
Rust https://docs.esp-rs.org/std-training/ https://docs.espressif.com/projects/rust/book/ Examples https://esp32.forth2020.org/ https://esp32.arduino-forth.com/ (https://github.com/MPETREMANN11/ESP32forth) Using timers for LED blinking (interval and rerun)
https://flashforth.com/index.html https://arduino-forth.com/ () MPLAB X IDE recompiled the ihex image, note that the ihex addresses are byte addresses not work addresses!
flashing it failed trying to write to bootloader section which is locked
can we fit it in side by side with the arduino bootloader?
why are the memory sizes in the IDE wrong after selecting the right chip ATmega2560
to produce an anotated listing file add compiler options: -Wa,-adhlns=${DISTDIR}/output.lst
I wanted to dip my toes in embedded programming for a while. Big part of it is nostalgia. The 8-bit MCUs are very much like the 8-bit microcomputers that I started on. It’s even better with the plethora of I/O options they provide. Reading the datasheets makes me feel like a kid in the candy store. The appeal is that the overall complexity is manageable, you can really understand everything that’s going on in the device down to the hardware bits.
I have spent a fair bit of time in Chrome Dev Tools recently and learned the hard way that you need to be careful with interpreting the flame graph that you get when you record a Performance profile. To illustrate here’s a fragment of a flame graph captured from a worker running Typescript’s ProjectService used to typecheck source files.
My naive interpretation was: the worker is receiving messages from the main thread over the LSP jsonrpc connection and calling openClientFile() in response.
Commandline nature of plaintext accounting (PTA) has a lot of benefits, but it makes the ledger inaccessible for someone who’s not inclined to type arcane incantations into the terminal prompt. Moreover it is suboptimal even for those who are, if you want to browse around without a very specific question in mind. An interactive graphical (or textual) viewer is more suitable in these cases. There are various options available for the most common PTA tools, however most require installing something or at least running a server to point a web browser at (e.
What I really want to write about is how I’m using plaintext accounting to track everything about my freelancing business. But I realize that before I describe my little scheme, first I need to say a few things about how I operate, for it to make any sense. I concede that it is possible if not likely that many may find the operations part more interesting than the accounting part. Hopefully at least some freelancers out there may find the second part interesting if not useful.
I’ve had this topic in the back of my mind for a while and recent talk by Russ Cox brought it back to the foreground. As with any of Russ’ writing it is well worth your while, I highly recommend you check it out. Of course he makes most of the points I wanted to make and then some, so my remarks will be mostly just a reaction to his talk.
I’ve been a fan of plaintext accounting (PTA) ever since I stumbled upon it about a decade ago. I was using gnucash back then for some time. While it’s a solid and well documented tool, the GUI paradigm just wasn’t working well for me. I distinctly remember that cumbersome manual input into the transaction “spreadsheet”. In comparison, the flexible plain text input with PTA felt like a breath of fresh air.
(Republished from Cincom Smalltalk Tech Tips)
Lately I’ve been working on an Xtreams based implementation of SSL/TLS protocol and I think that some specific parts of that could make interesting examples. Examples that are non-trivial, real-life solutions rather than some artificial academic exercises. This is my first attempt to extract an interesting example, hopefully without getting bogged down in too much detail. Although I will try to explain the constructs used in the example, it will require some basic familiarity with Xtreams, the documentation at http://code.
(Republished from Cincom Smalltalk Tech Tips)
We are receiving some very encouraging feedback on Xtreams . There’s a fairly complete port to Squeak/Pharo, people are blogging about it, and discussing it on various forums. All that is very welcome and certainly helps reassuring Willow and myself that we might be onto something that’s worthwhile and keeps us motivated to continue.
At this stage of the game we feel that the core library is reasonably complete, we’re reasonably happy with the API and we’re venturing into experiments where we’d like to prove that the concepts and implementation are good and that the performance goals are achievable as well.