Awesome Sauce Java with Hot Sauce OS

In This Article: Configuring Awesome Sauce Java & Apps Update About Package Design A Language Without Normal Package Declarations Configuring Awesome Sauce Java & Apps: Git It? Well, with enough features in place, and enough R&D, it's now possible to start building.  In the last few weeks, macros and mediators have been upgraded/redesigned, and, while working on those two parts of the program, a bunch of other things have been either sketched out or worked on simultaneously. All the work is leading up to finally being able to build from the ground up. With a stable Awesome Sauce Java, access to the JDK, and a growing set of Lisp functions, it's going to be possible to start another iteration on aspects of the Hot Sauce OS. The first thing I'm doing to build the OS is configuring the code. Awesome Sauce Java is the basis for Hot Sauce.  I'm exploring providing a configurable programming language.  What that means is being able to build libraries ...

I'm reorganizing. What that means is Awesome Sauce Java is going to become structured for release.  Since the release path is forked, the structure of the project has to provide easy configuration for shipping: Stand-alone, Java based Awesome Sauce Java apps. Hot Sauce OS style, all apps running in their own threads & managed by Hot Sauce, based configuration. So all the code is getting moved and re-Git-ified to make sure all the parts can play nice, regardless of which release is being built/updated/released. One of the things I was working on last night on the train was making sure that both release formats provide the ability to edit the application while it's running, even after release, should the developer want their users to be able to edit and modify their application. What this means is that applications need to be able to connect to the ASJ Editor or ASJ Interface Builder apps.  The app, say it's a spreadsheet, needs to be able to connect to the devel...

[Update] Wow. I just figured out what I was blocked on and...wow! Was this difficult. What I was working on goes way back to early prototypes and a problem I thought I had figured out, but really didn't, but it was good enough to build apps, but not really that right, but I used it, because it was all I had.  Where I was frustrated today at not getting things done?  Now I'm really happy because I have a rock-solid design. Phew!  But read the article below and when you get to the end, this will make sense!  Writing a programming language is wildly different and fun! The Original Introduction Is Below This Line Just a quick note. I'm learning why I get blocked when I'm not able to really make progress the way I'm attempting to.  I noticed today that I get intense fears or anxiety related to getting things done. The tension is pretty high. The fear I feel is probably not unlike any normal fears that anybody else feels when they sit down to work. The difference...

It's kind of a weird thing to be saying, but Awesome Sauce Java is going to make it possible to evolve Java.  I've mentioned it before in a prior post.  But, by virtue of the design, ASJ will provide users with standard JDK Java calls, in a functional form, standard Lisp calls, new idioms, and modified/simplified/cleaned-up Java JDK & Lisp calls. I was just looking at both Java and Lisp code.  With regards to the Java code, I'm going to start with modifications by eliminating obvious redundancy.  Where a call contains the name of the argument, I'll eliminate it.  For example, the call to processWindowEvent( WindowEvent e ), could just as easily have been called process( WindowEvent e ). While it's going to take a little time, it just makes sense.  Because once the redundancy is removed from the calls, the language becomes easier to work with.  Calls become easier to remember and expressions become more expressive. I'll be doing the same with ...

I Only Sound Confused Until I'm Positive I didn't know I was going to be addressing this in Awesome Sauce Java.  But apparently, being on the inside of a Lisp invites exploration and all that exploration leads to wonder and now I'm standing inside a region of software I never wanted or planned to be, with a possible approach to possibly simplify some complicated things related to packages, with no confidence anybody is going to care. I'm tilting at windmills. Names are a vexing bane in software. Names are confounding in software. Just trying to get this article started has me confused. Maybe a little angry.  Packages are great, but they're not, but it's not nice to complain just to complain.  Best to point out the why they're great and why they're not, then show how to improve them. Packages are the best.  Maybe the best it can possibly be.  Whatever packages are?  They're a really, really, really, truly difficult hard problem. There may n...

I need a job. Meanwhile, I keep writing, because what's the point of saying you can write code if all you're doing is reading job descriptions, writing cover letters (barely), and sending resumes (barely, too)?  I spent years sending letters and applying for all kinds of jobs. Strangely with literally no response. Ever. I work. It's been a strange 7 years since getting assaulted by that guy who came close to tearing my head off. Today I'm working on and writing a few things:  Class definitions. With Awesome Sauce Java, you'll be able to create class definitions like Java defclass definitions like Lisp. One of the things I'm exploring is merging class definition into a new form that's like a combination of both the Java and Lisp methods. If this comes to fruition, it won't obviate class or defclass, just be another way to create classes. Concurrency Oh boy was I thinking about concurrency last night and this morning. Will write a separate ar...

Making it on a Shoestring I was working on Awesome Sauce Java last night when I started thinking. Then it hurt. So I had to stop. When I started writing a programming language, it was fun and new. It went pretty quickly, too. But it went quickly for a couple of reasons. The first was that the language was small. The second was that the functions I picked to implement were pretty easy. I was just getting started and wanted to limit the complexity. By keeping one side clear and easy to validate, I could know where a bug was happening when they inevitably cropped up. As the language has grown, things have become more intricate. Sometimes new additions alter the way the reader processes tokens. Or sometimes new code alters the way eval works. Sometimes things just break and it's not clear why. What I noticed is sometimes things just take time to figure out. I was starting to be frustrated with my pace and felt critical that I wasn't going as fast as possible. Or a...

The possibility exists somebody stole my code.  I know nothing about security or firewalls.  My computer's been hacked before.  My ideas are probably gone.  Worse, it's likely I'm being made to look like I'm the one who took the idea.  I started ASJ as a product called Spliff (Lisp + Java as Splivaja sounded ucky, I wanted Lisp in the name, so for a while, it was Spliff.) I started it all in 2015 and have written it without any assistance since.  I made all the design decisions for the internal structure, and have used the language to design new features that are exciting and advanced.  I'd hate to lose it to somebody else, but I'm also one short step from homeless, smell like racoon crap, and get harassed like a Dhimmi in NYC of the state of New York, in the United States of America. Nobody believes me and it's a frightening place to be.  Especially with the stack of inventions I have.  Or thought I had.  People steal.  People ...

I'm not summiting anything anytime soon, but I liked the title.  It's kind of appropriate, but unlike real life, the summit in software is the next peak from which to start the next ascent into the unknown.  I hope.  While my life is chaotic due to what I get to call spatial blindness and brokenness to time, when I write ASJ code, it's pretty fun to experience what grows. This morning on the train, I had the chance and the perspective to review what ASJ is, how it works and where to take it next.  I'm pretty sure getting macros moving/working has really taken a load off my mind.  One thing I've noticed recently, and I hope the awareness is a sign of healing, is that when I sometimes think of something I have to build, there's a big fear that overwhelms my logical mind. In the abstract, it seems to make sense that fear would overwhelm certain thoughts or behaviors, as the most likely area to suffer when violently clubbed in the front of the head is the higher...

While reading macro definitions in OnLisp, by Paul Graham, I was reminded that macro programming is different.  A normal program is written with standard considerations to scope, instantiation, state, atomicity, mutability, and the myriad other purposes for bringing code into existence and the meta-detail surrounding it.  Macros are different in that they deal with, among other things, expansions, like: e=mc^2 I wrote this the other night while simultaneously wrapping my head around macros and wrestling my personal demons: Macros are wildly untame critters. They expand as text, they get evaluated as code, then expanded, then...they keep expanding and evaluating.  Macros are to programming what quantum is to physics.  Without macros, e=mc^2 would have looked like, "Math Vomited Onto Paper", and Einstein would have sounded incomprehensibly complicated trying to make his physics simply approachable. "No really! It's called Relativity! There's light and eleva...

Well, last night I put the macro calls in the right place and made them work.  Initial tests are solid.  Code looks good.  I'm shocked.  Not because I lack confidence.  I may be kind of broken, but I've written device drivers, medical CAD, memory managers, a bunch of apps, and software that might be considered challenging. But macros are different.  Maybe they're a little tricky, but once I got where they went and what they did?  I got them.  I was slow to get to understanding, but I knew I'd sort them out.  It's maybe more the beliefs I've had about writing a Lisp implementation, much less a Lisp implementation that's Java-based, merging both Java and Lisp into one language. For 17 years, I thought about writing a Lisp.  The more I used and learned Lisp, the bigger and more complex the language seemed to be.  While I hoped to one day have the opportunity to write a Lisp, it felt like a huge undertaking, one that would push me t...

I've been working on macros for a while now. They work, but I'm not confident.  Not that I'm not confident in my abilities. I'm not confident I understand macros.  I get that they're backquote, comma, and comma-at.  The parsing is all in, the right things are getting the right calls, and things are getting constructed in the right places and ways.  I know that I'm not seeing something right. I just don't know what it is I'm not seeing.  So, I'm reading OnLisp about how and what and why macros are, so I can see what it is I'm blind to.  This is kind of my normal.  The language holds my hand until something happens and I can't see the hands anymore.  Then it kind of becomes a blind game of sounding out where I am and where it is, so I can slowly orient myself to go the right way and feel my way through what I need to build.  It's weird because I can see and hear and speak, but there's a lot broken on the inside of my mind (from a lot ...

I couldn't figure out why my productivity was dropping.  I had a sense that my workload was spreading out horizontally, which makes sense, because as Awesome Sauce Java becomes more mature, the tests lead to ideas, applications, and implementations.  Many of the ideas are close to being finished products, but for a piece they're waiting on to turn them into a final release.  That's the nice part about building a language on the JVM - it works and works well. But this morning, I put together a list that I'd been trying to figure out how to put together.  What that means isn't to build a list, I've done that many times and for months.  The problem with being spatially blind is remembering that I wrote a list AND where it lives. Recently, at the beginning of Februrary, I'd found a mechanism that helps me remember, so I'm exploiting it.  My hope is it'll turn into an application that not only allows me to store my thoughts, but keep them in front of ...

I was giving a demo to my son the other day.  And it was awful.  I've been working so hard on just exploring and framing out enough of Awesome Sauce Java with Hot Sauce, that it's a developers dream, but an "elevator pitch" nightmare. Fortunately, it'll be easy to fix.  Once I get macros implemented, I'm going to finish a configuration I started the other day that will make it possible to manage the state of all the parts of everything related to showing what makes ASJ w/HS special.  I mean, I'm supposed to say it's cool.  But, since you don't know me, you might think I'm just hacking on something because I think it's cool. Truth is, I can only work on things that are measurably "better" with respect to some meaningful metric.  I've been working on software continuously since 1980.  The weird part about my career, is that it tanked after a savage head injury.  At the time, I was at Apple.  They had just made a job for me, ...

I keep forgetting to remember to talk about macros in Awesome Sauce Java. Among the language features that are distinctly Lisp, that Lisp programmers point to as essential and powerful and differentiating?  Macros are it.  Making them available to a Java-based language, as fully-functional macros, will hopefully be a positive thing. Lisp macros provide the means to transform code. They're often viewed as syntactic sugar, but that diminishes what macros are. This is how Graham describes Lisp macros: Lisp's macro facility allows you to define operators that are implemented by transformation. The definition of a macro is essentially a function that generates Lisp code - a program that writes programs.  From these small beginnings arise great possibilities, and also unexpected hazards.  Paul Graham, OnLisp, pg 82 Paul Graham goes on to say that macros are different than functions.  They work differently than functions. Functions produce results. Macros produc...

My life has been fun, but at times quite challenging. Drought, earthquakes, crazy numbers of cats and at the same time, bugs, head injuries I watched from 15 feet away from my body, bad doctors, and a whole lot of bad characters. But I keep going because it keeps getting better.  I've been poor a long time, but I know money will come. How do I know? The drought ended. Nothing lasts forever. Bad people might try to make us look bad, but the truth always comes to light. Which brings me to Awesome Sauce Java with Hot Sauce.  Awesome Sauce is the language. It's dynamic and fast and puts Java in a format that works for me. I've learned more Java with it than ever before. But it kicks my butt a lot and frustrates me. Like today, while working on the HTML generating code, I realized I implemented macros in a weird way. Or I'm not understanding how I implemented them.  That happens sometimes when I haven't worked with a set of logic, block of code, or mode of operatio...

Working on the core of the Awesome Sauce Java language.  Been doing a lot of work on the piece that integrates the low-level language details with user interface details.  It's coming together well. There's so much going on with this one piece of software, I have to think about how to present it.  It's also a new way of interacting with code...for me, at least. Maybe kind of new in some way.  I think.  It's definitely weird and new.  Because it's functional Java, with Lisp, in an environment that obviates a lot of the normal overhead of coding. Plus, it's allowing me to start building user interfaces.  Which is why I'm keeping this short.  It's so much fun to be exploring while also constructing, I want to get back to it. But I'll share this.  I wrote an application a while ago.  I'm using that application to build the Interface Builder and provide the bootstrap code that's going to allow the Interface Builder to use the same mecha...

I need to clarify an important aspect of Awesome Sauce Java with regards to method names and evolving Java.  Awesome Sauce Java can offer (at least) three different types of method signatures with regards to the name of the method and the return type.  There are many aspects of Java that can be modified, but the first that makes sense to present is with regards to method names and return types.  Here are the three types of method signatures I'm going to offer in Awesome Sauce Java : Standard Java calls Nothing changed in any part of the method signature. Standard Java methods altered to become Functional Java calls Returning a value that makes sense in the context of functional programming. Upgraded/renamed Java calls that either preserve the Standard Java method signature, or offer a Functional method signature. I'd like to take a minute to show what it means to evolve Java, because without clarification, it could sound like the Awesome Sauce Java ...

Extending the Reader to process Spreadsheet Formulas This is kind of a weird but fun experiment.  Today I altered the Awesome Sauce Java reader so an application can extend it to process symbols. The concept started as is a way to process Awesome Sauce Java forms entered into a spreadsheet cell: (+ 1A 2A) Note: I'm inverting the normal cell reference labels to follow row/col format. I'll probably change it, but I like the different order. When I looked at the formula, I realized it needed to be processed either in a special reader, or in the actual reader.  The fun part about building a functional language that's modeled after Lisp is the recognition that every problem is associated with a part/component, or a function.  The structure of the language greatly simplifies the architecture. As soon as I realized the spreadsheet had to convert a cell reference, like 1A, and convert it to the value held in cell 1A?  It became apparent the next problem was figuring...

This is as much a reminder to myself as it is an update for you.  While working with Awesome Sauce Java, it became clear that it does at least two things: It works just like Java, because it exposes Java as Java. It can be modified to work just like Java, but it can be changed: To become functional, by e. g. returning values from method calls that currently return void. To support concurrency, by eliminating side-effects. To clean and edit method names, to shorten them and/or make them more representative of what they do. The list of ways Awesome Sauce Java can change Java is considerably longer, but I first wanted to highlight these three important ways in which it's possible to modify Java.  Modifying Java isn't something to be taken lightly, but providing the same functionality with more consistent names, that are possibly shorter, may help the language become more usable and improve programmer productivity. How Awesome Sauce Java Can Evolve Java Beca...