v9v

> Still, expert reviewers will occasionally disagree in their labelling. To ensure quality, an audio clip [box characters], at which point [...]

Have they censored their own article?

Reddit provides RSS feeds, which this app is claiming to support.

I would argue that kobold.cpp is even easier to use than Ollama. You click on the link in the README to download an .exe and doubleclick it and select your model file. No command line involved.

Which part of the user experience did you have problems with when using it?

There seems to be a github repo here with binaries (but you need to get maxima separately, probably from sourceforge): https://github.com/wxMaxima-developers/wxmaxima

Raymond Toy posted this on the ECL mailing list: https://mailman3.common-lisp.net/hyperkitty/list/ecl-devel@c...

I remember reading that the Bluetooth stack was one of the main differentiators for Pebble at the time due to its reliability, shame it's not included here.

I'm assuming that the "use dylan" is there for similar reasons as to why you declare that a package uses :cl in common lisp: This way if you want to define your own functions that replace those in the language (eg. a custom + function) then you can simply omit importing the dylan namespace and define those without worry of conflicts.

I think most people buying RPis for the GPIO would be better served by a small microcontroller devboard like the Arduino Uno acting as the intermediary between the computer and the wires. This way if anything goes wrong (overvoltage, short) then the Arduino takes the impact and is much cheaper to replace.

I quite like the concise state machine definitions used in Rodney Brooks' "A Robust Layered Control System for a Mobile Robot"[0]. The first element is the state name, and whatever is returned is the next state.

  (defmodule avoid
    :inputs (force heading)
    :outputs (command)
    :instance-vars (resultforce)
    :states ((nil (event-dispatch (and force heading) plan))
             (plan (setf resultforce (select-direction force heading))
                   go)
             (go (conditional-dispatch (significant-force-p resultforce 1.0)
                                       start
                                       nil))
             (start (output command (follow-force resultforce))
                    nil)))

[0] https://www.semanticscholar.org/paper/A-robust-layered-contr...

There is enough space on large robots to add in beefier compute if needed (at the expense of power consumption). Python is run all the time on robots. Compute usually becomes more of a problem as the robot gets smaller, but it should still be possible to run the intensive parts of a program on the cloud and stream the results back.

Tangentially related: http://bactra.org/notebooks/cumulants.html

Rivet (https://tcl.apache.org/rivet/) may also be of interest.

The battery life and IP rating are a bit disappointing. Having to charge your glasses ~twice a day sounds like a big ask.

A better writeup here: https://reader.tymoon.eu/article/437

Similarly, some versions of Siemens NX (another CAD program) can go up to $45000 according to this reddit thread: https://www.reddit.com/r/SiemensNX/comments/ws66tm/whats_the...

Also see Muntzing: https://en.m.wikipedia.org/wiki/Muntzing

I think a good example of this concept is the foreach command in Tcl: It's quite flexible compared to list iteration constructs found in most languages.

This is normal usage:

  foreach x {1 2} {puts $x} => 1 2

You can iterate over two lists at once:

  foreach x {1 2} y {3 4} {puts $x $y} => 1 3 2 4

Instead of reading one element from the list, you can read multiple:

  foreach {x1 x2} {1 2 3 4} y {5 6} {puts $x1 $x2 $y} => 1 2 5 3 4 6

If any of the lists happen to run out before the others, instead of complaining it just returns empty elements.

Many commands in Tcl give the impression that they can be used in many different ways, so writing a program in Tcl feels like building a structure by creatively assembling a limited set of legos.

The same labels can be found on Leslie rotary speakers: https://www.hammondtoday.com/img_4719-2/

Not sure about smaller or simpler, but Ada is definitely more readable in my opinion.

FL Studio, a music production program, is very popular and developed in Pascal to my knowledge.

Very impressive. Comparing the slow-mo to one of a different rubik solver [0], there's much less overshoot in this one.

[0] https://build-its-inprogress.blogspot.com/2018/03/the-rubiks... (see first video)

>They are named after population groups, but who were the Aeolians, the Lydians, and the Phrygians?

>They were slave groups, conquered by the Greeks in Asia Minor.

This is incorrect. Each of these were separate civilizations and not names for a "group of slaves". This can easily be verified by a simple search so I don't even understand where such a misattribution comes from.

The Google chapter of "Lisping at JPL" (https://flownet.com/gat/jpl-lisp.html) may be what you are remembering.

There's https://wavedrom.com for digital timing diagrams, not exactly the type of diagram you want but still useful.

The NYT Connections benchmark sounds interesting, are the results available online?

Julia (and MATLAB) have large, heavy runtimes making them non-ideal for applications where size and startup speed matter, eg. libraries, edge computing.

Their dynamic nature makes them much better at exploratory programming compared to Fortran though.

not sure if it's different from what you are saying, but the elemental specifier[0] makes functions broadcastable, such functions operate on each element of its input separately.

[0] https://fortranwiki.org/fortran/show/elemental

Emacs has EIN which allows you to edit and run Jupyter Notebooks. Combining that with a vim keybindings mode like Evil, you can use vim bindings on notebooks.

Edit: The github page for EIN says that development has stopped. Despite this, I was able to edit a notebook with only minor inconveniences very recently.

I'm curious how they plan on covering the cost of their cloud services without a subscription fee.

I like the MATLAB REPL a lot with regards to this issue. If you make a typo in a function or variable name, the REPL fixes it automatically and you press enter to send the corrected command. From the story submitted here about Medley Interlisp, I gather that its REPL also has such a feature.