I'm building a mod for the game Subway Builder (http://subwaybuilder.com) that lets me undo/redo individual stations and tracks, instead of clearing all blueprints.
I can't begin to imagine what this world would look like, but I can keep dreaming...
I think splitting up Maps from Google/Apple would make OpenStreetMaps see a lot more usage and improvements.
Amazon Shopping should absolutely be split into an online store and a logistics company.
I'd like to see something even more radical when splitting up Infrastructure (AWS / GCP / Azure), such as the Government offering Infrastructure similar to the Postal Service, effectively turning AWS / GCP / Azure into Fedex / UPS.
It looks K-centric. The K language provides constructs like each, over, and scan to perform what would be looping behavior in other languages.
Having written Scala myself at one point, the thought of a loop-less language crossed my mind. It's amazing what you can accomplish with foldLeft and recursion schemes.
They're loops with stronger semantics (in other words, they're more restrictive (in other words, they're easier to reason about)), in the same way that loops themselves are `goto` with stronger semantics.
> they're more restrictive (in other words, they're easier to reason about))
That's a great point. Often in my programming career, I've used the rule of least power[1]. In the looping/flow control ladder, I'd list descending
* JMP/GOTO
* for/while
* map/filter/reduce
If a problem only needs a map, using a for introduces needless complexity(ie: state). Personally, I think we have a pedagogical problem in that we teach people loops first and people confuse what they've been taught first with what is a reasonable choice[2].
For completeness, recursion has it's own ladder
* PUSH,POP,JMP
* function call
* recursion schemes[3]
Side note: recursion schemes have an enormous hurdle to adoption in that mathematicians got there first and the naming are so off putting that no one will take you serious if you bring up even simple schemes like anamorphism and catamorphism. Folks would rather accept a FactoryFactoryFactory over a futumorphism.
Aren’t loops just wrappers around goto and if statements?
The claim is that by expressing programs in terms of these array primitives, you (a) can have those primitives be super optimised and (b) better see what the program is actually about without worrying too much about eg what names to give all the loop counters, all the other intermediate state associated with iteration, etc.
Loops themselves can be considered just convenient wrappers around goto. The point is to restrict the variety (structured programming) and make spaghetti unreadable code less likely.
Using higher-order functions instead of loops is similar e.g. loops:
# input_ = "1,2,3"
numbers = (int(d) for d in input_.split(","))
product = 1
for n in numbers:
product *= n
Sure, and C is a convenience wrapper around assembly and assembly is a convenience wrapper around toggling octal codes on your front panel and punching in octal code is a convenience wrapper around rewiring vacuum tubes and relays and that's a convenience wrapper around mechanical cogs and that's a convenience wrapper around an abacus.
But it's a different paradigm than procedural programming and embracing it might lead to a different mind set.
Lol. IMO the difference between an C and Assembly (as between vacuum tubes and the abacus) is really a difference in power, since it allows the same program to be implemented on different architechtures. It's only fair to start calling things convenience wrappers once you get past C. And often enough, an abstraction aimed at convenience leads to a reduction in expressive power.
Loops (Eg: in C) are a much “wilder” construct — something special could happen for i=17 or successive iterations might overwrite values, etc. more restrictive “tamer” versions help programmers & computers reason about the code.
I would claim that SQL is the ubiquitous loop-less language.
Once you get into it, you start realizing what manipulating data is all about. And most of what you need can be expressed without for loops. And then the step from SQL to Scala is not long.
For me imperative languages are like Lego. SQL is like origami. You fold yourself to the solution.
That said, K is obviously one step further in that analogy.
It promotes array languages, where operator symbols indicate actions on an n-dimension array (0 = scalar, 1 = vector, 2 = array, etc.)
As a trivial example, A + B means the element-wise addition two arrays, rather than use looping to compute the terms yourself.
The original array language is APL, which is also known for using its own non-ASCII notation. https://en.wikipedia.org/wiki/APL_(programming_language) . To give you a sense of what I mean, the implementation of the Game of Life is:
Compare that to how you might implement GoL as a couple of for-loops, with a hard-coded count of the 3x3 neighbor grid. But why use stinking for-loops when you express what the result you want directly, tersely, so you can able see the whole program at once?
(OTOH, as I recall, that implementation uses a fixed-width array, which highlights a limitation to using that approch. For GoL you really want to use Hashlife, which isn't so amenable to an array approach.)
Many of the links here reference K, a descendant of APL which uses ASCII.
"APL's array operations are also ideal for implementation with SIMD, or "single instruction, multiple data", operations, that perform a single action on several different values. In some cases, such as scalar functions, the primitives are SIMD operations; in others such as Reverse, they are easily implemented using SIMD—for Reverse, SIMD selection or "shuffle". While experimental SIMD machines (such as the APL-influenced CDC Star-100) were created as early as the 1960s, SIMD computing first entered the personal computing mainstream in the 1990s and has steadily grown in prominence for high-performance computing since then. In APL, CPU vector instruction sets such as Intel's SSE are the most often way to access SIMD optimization, although Co-dfns instead runs on a GPU to attain much higher throughput at the cost of increased overhead and restriction of available algorithms."
I copied it from the Wikipedia page, which also shows a layout for an APL keyboard and has a picture with the mechanisms to get your typewriter/printer to handle it.
Supposing I'm "Joe HN User". I've worked with both Lisp and Numpy. How do array-based programming languages relate? Are they just syntactic sugar for things I could already do in Lisp/Numpy, or is there something more?
As a slight tangent to your question- kdb/Q works beautifully with numpy, it’s very useful being able to work with numpy from the q prompt and pass objects between the environments.
Old Bay is much more recent. It's based on a lot of spice blends dating to the mid 19th century but Old Bay in particular is only from the 1930s.
It was originally for crabs, and that particular dish really is a distinctive local tradition. Applying it to everything and calling it "Maryland" really only dates to the 70s.
First thing I noticed since I'm sitting here in Mountain View looking at a nice sunset just above the horizon (or specifically, the Santa Cruz mountains), so nope, not close to dark yet. Maybe another hour.
I'm curious to find resources on learning this tool however I was only able to find the tutorials from LXStudio.
Is anyone using this software in production and can comment on its experience vs. TouchDesigner? TouchDesigner's node system always pissed me off, as it felt like an unnecessary barrier that just made things harder.
Also in general, any VJs on hacker news?
EDIT: Some more instructions to run the application would be great, after loading the project locally and running `mvn validate`, I'm seeing the program execute but nothing is showing up on my screen.
I heard about LXS yesterday at the Burning Man Decompression event in SF. One of the creators [1] of the ladybug LED art installation told me that the ladybug is running LXS. They seemed friendly so you could probably totally just email them [2] for their take on LXS.
Seems to be an issue with the latest macOS update, they had similar issues in macOS Ventura and I copied the fix over for macOS Sonoma and was able to see the IDE after running from IntelliJ.
Thank you for that. As mentioned in some other comments, I've given up continuing to use Processing as an underlying application UI framework. It's unclear how long the OpenGL dependency is going to survive on macOS, or that Processing will have the dev resources to break the hard OpenGL dependency (sad side-thread on that topic: https://twitter.com/ben_fry/status/1709400641456501020)
Future version based upon lwjgl+bgfx will be more broadly available soon.
I'll add that I'm at out of work Software Engineer with a BS in Comp Sci and I've been researching to see if a Masters in ML/AI is worth it.
I haven't seen anything indicating it's essential, and I still see that with a MS in AI/ML you're still most likely going to be doing Software Dev... I'm sure it's different for a PhD, but as the other commenter said, it's going to take a lot longer.
