Third Brick Wall

Alan Ruttenberg alanruttenberg at
Sat Jul 25 04:34:41 UTC 2020

Try just using a java list.  As I understand it, that should work the same
Since Java.util.List is abstract,  you need to choose a concrete class,
such as ArrayList.

(let ((jlist (jss::new 'arraylist)))
  (loop for el in '(1 2 3 4 5)
        do (#"add" jlist el))
  (print (jss::jlist-to-list jlist))

The print statement is to verify that we got what was expected, and to
demonstrate jlist-to-list.

On Fri, Jul 24, 2020 at 10:21 PM Steven Nunez <steve_nunez at> wrote:

> I think what parallelize
> <>really
> needs is a java.util.list. Alessio mentioned some reasons why an automatic
> conversion is challenging; perhaps a restart is easier? I.e. search for a
> method of the given name that takes a java.util.list, and if you're giving
> it an abcl.cons, the restart asks if you want an automatic conversion.
> Trying such a conversion manually, it seems I need a jlist-from-list, but
> this doesn't exist in the JAVA package.  How do I get a java.util.list from
> an abcl.cons ?
> On Saturday, July 25, 2020, 5:20:30 AM GMT+8, Alan Ruttenberg <
> alanruttenberg at> wrote:
> If you send a smallish example of the code that doesn't work, and a list
> of the dependencies, I can have a look. I've been dealing with some stuff
> recently that might make it easier to debug.
> You definitely can't use CopyToArray that way. You need to work with a
> java array
> (jarray-from-list '(1 2 3 4 5))
> Maybe:
> (#"parallelize" *sc* (jarray-from-list '(1 2 3 4 5)))
> Alan
> On Thu, Jul 23, 2020 at 11:03 PM Steven Nunez <steve_nunez at>
> wrote:
> OK, I'm on lines 4 and 5 of 'hello world' and ran into yet another brick
> wall. Trying to convert the following two lines into ABCL:
> List<Integer> data = Arrays.asList(1, 2, 3, 4, 5);JavaRDD<Integer> distData = sc.parallelize(data);
> it looks like it should be easy. Heck, I can do that in one line:
> (#"parallelize" *sc* '(1 2 3 4 5)) ; *sc* defined yesterday and known to
> be correct
> But no, it claims "no applicable method named parallelize found on
> JavaSparkContext" (but there is!). Reading through section 3.1.1 of the
> documentation, it appears that this is probably because '(1 2 3...) is a
> LispObject and not a Java object (why no automatic conversion?). Let's try
> to convert it:
> (#"parallelize" *sc* (#"copytoArray" '(1 2 3 4 5)))
> No instance method named copytoArray found for type
> org.armedbear.lisp.Cons'
> And the same with using an array, e.g. (#"parallelize" *sc*
> (#"copytoArray" #(1 2 3 4 5)))
> *Sigh*
> It's been a week and my intention was to have a working prototype by now
> and present ABCL as a viable alternative to use in a project. I haven't got
> past line 5 in 'hello world'. This doesn't bode well.
> I've been reading about ABCL for years, and it's impressive. Full MOP,
> extensible sequences, nearly 100% ANSI compliance, and the ability to
> deploy on the JVM are major achievements. However, as a not-inexperienced
> Lisp programmer, I find the barrier to entry remarkably high and the
> documentation and examples sparse and insufficient to surmount the hurdles
> I encountered.
> Please take these comments in the way they are intended: constructive
> feedback from someone who is a fan of the project and would love to be able
> to use it. It's nearly impossible to get Lisp introduced into enterprise
> environments, and ABCL provides a wedge into those types of projects,
> ticking the boxes on deployment and ability to work with legacy Java code.
> Perhaps it makes more sense to someone approaching Lisp from the Java side,
> but coming from the Lisp side to Java, there's a high barrier to entry. I
> know that no volunteer wants to write documentation, but more and clearer
> docs are sorely needed here. This is probably not news, but sometimes it
> helps to be reminded of the obvious.
> I hate giving up, so this will be a personal background project in the
> hopes that at the next opportunity things will have improved to the point
> where we can consider introducing ABCL, so if anyone has any pointers,
> generally (though I think I would have found any docs or examples (lsw2) by
> now) and explaining this problem in particular, it would be greatly
> appreciated.
> @easye, you mentioned your ember project. If you're going to continue with
> that, please message me. A Spark wrapper would be useful, serve as a good
> exemplar for using ABCL to wrap a large library and, with a companion
> tutorial, help others overcome the kind of obstacles I've encountered. I'd
> be happy to contribute.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <>

More information about the armedbear-devel mailing list