Hello 
I am trying to find a non-conformist programmer that likes to program in eclipse + Java and eventually jme. I am interested in constructive brainstorming about building concepts in Java from the group up, sort of like we base this system on that system and sorts. Basically I donāt know exactly what I want and I donāt want to come of as pretending that I do. But one thing is for sure, I cannot do this alone, due to being easily distracted by other things and I am pretty sure that if I was doing this project with someone else (at least one person would do) then I would keep on it.
Whatās the project supposed to be about? Itās not easy to explain. Eventually it should be like an user interface in jme (jme3 letās say) - although I have zero experience in jme3 and only 0.000001% experience in jme2 
. In this interface we can manipulate objects that are the representation of the real objects stored in a BerkeleyDB database (BDB for Java). Basically when itās ready we should be able to store any information in this environment and have it do any computation. The information stored should be easily understood and most importantly, you could start from anywhere in the system and be able to parse (and at the same time understand) the entire system. I realize Iām talking way too general here, let me see if I can give some examples. Say for example we define within the system(environment) the letters from A to Z, and then we want to create words in English, we would use some kind of pointers that will point to those letters, instead of duplicating the letters themselves, in this way we can use the UI the go to letter J for example and see all words using that letter as their first letter. Eventually we can make phrases that use words similarly, and even have phonetic words that can be traced down to words in English or in other languages that have the same phonetic sounds. This is just a simple example (and poorly explained, left so many assumptions)
My way of programming is a little too weird perhaps, because I am always trying to make sure to make assumptions/defaults/implied things be explicitly declared (or so) for example:
[java]public
boolean
isWhoState(
final WhoState who )
{
Z.assumedNotNull( who );
if ( who == whoState )
{
return true;
}
else
{
return false;
}
}[/java]
notice the extra method testing for null and the extra else
In other words also, Iām not really much for compromises and also Iām a (neurotic) perfectionist(basically wanting to do things right but failing and postponing them for the future:) - yeah I know itās unwanted:P), so this may prevent me from ever completing the projectā¦ but if we were two (or more) we might drive each other to keep working on it, since Iām more likely to do something for (or because of) the other person than for myself.
Also another thing to mention about the project, I guess, itās that it has to have the ability to allow multiple threads of execution(not necessarily java threads - probably threads as defined inside the environment, even though this doesnāt tell you anything) and these threads should be able to access read/write objects (read: lists and pointers of sorts) in such a way that they wonāt block or lock or invalidate the database(not really talking about BDB database here) state. We could brainstorm lots about this, although if we think what git/svn/cvs/rcs do we might have the basic idea of multiversioning ā¦
Also, the project would be free as in freedom and free as in money and also open source and probably stored on sourceforge.net (since they use git, unlike googlecode - I may be wrong) and likely released under GNUv3. (I guess the first free and open source are the same thing here?)
So, imagine having the ability to completely define your own system (in this environment) using stuff that already exists and having all of them properly and explicitly (as opposed to implicitly I guess) connected such that accessibility is the main thing. While Iāve had this idea for about 5-6 years now, only recently Iāve come to realize that the Java language may be defined similarly internally, however not completely I guess - unless I donāt know how to dynamically change/add executed code using reflect API.
These objects in the environment are supposed to be lists, such that each element can be either the list itself or itās elements can be empty or non-empty lists, but even these have to be build on top of something like a Set of elements and then double linking the elements to form the ordered list.
Iāve noticed how so many open source code is freely available but not so easily readable due to having lots of assumptions with which the reader has to come with (the reader must have this background and fill in the assumptions) instead of having the system keep/have defined these connections within it. Basically if youād make a computer program and youād point it to a source code program he wouldnāt understand it because itās just a text file. Now in this environment that I tell you about, it would be real easy for a computer program to understand such a source code , assuming it was properly defined in this environment, for it can be seen as a grouping of expressions made of words composed of characters OR it can be properly defined within itās language (ie. C or Java) such that you know that expression Object o=new Object(); is actually a statement declaring a new variable o as being of a class Object which in turn is eventually using the word Object made of a grouping of charactersā¦ so onā¦
When the project is ready, one should be able to just change on line of code and the binary and doc relevant to that code would be automatically updated but not recompiled (sort of what make is doing when youāre changing contents of one file, it rebuilds only that file - but Iām saying rebuild only those that depended on the change) and this is if one would even want to have a binary and doc to it, because the binary and doc would be the sourcecode itself at this point. Sure it may be slow (you may think) but itās accessibility and readability that is the most important thing here, not how fast it runs (optimized for speed) or how less space it uses (optimized for size) even though those can be implemented too. Any new feature could be added without upsetting the already defined stuff.
Hereās a representation (in this environment shown maybe in jme, though it was made in some graphviz manually) of a table inside a relational database and itās log:
fields and their data inside the table:
ID, Operation, Param
1, create, A <ā this is record0
3, delete, A <ā this is record1
and the log would be:
record0,
record1
and how it would be represented inside this projectās environment when itās ready:
this image was done about 3 years ago and thus not all subsystems are visible, basically you canāt see any sets of sets, all lists are supposedly ordered here although the real order is unseen, all circles are lists, and all arrows point to children of that list, children which are in a certain order in the list.
Enuf said, whoever has the time and resonates with this and is open to critical thinking and annoying brainstorming :)) just post a reply I guess for now, we can theoretically chat (chat-only I guess) in gtalk (or pidjin) for I have no other forms of communication and I donāt plan on using them (though I am open to suggestions ofc). Also I think that credit is irrelevant really, for I or we are just the medium thru which the information manifested itself, and are not really the creators of it, and so giving credit to me or whatever, is not important for me, also because so many people and information influenced us in so many ways that credit must be given to anybody for this - also this entire idea and even parts of it are not new at all and is used in all the places and yet Iād still like to have this kind of foundation to build stuff upon, to define concepts upon to make use of anything defined within it and realize how all is connected (as it is in our universe anyway - at least by thoughts, on that level)
Feel free to leave a reply anyway, even if this annoyed you lotsā¦
Well I dont know if this is really the way to attract people but I guess you just try to be true to yourself, I dig that Still Iād say presenting some code instead of just the āmasterplanā will get you more response.
Your basic idea of lists that define an object is something that will probably be integrated in the Entity system for jME3 that I am working on. Although its not very OOP style its a nice āflatā system. The idea would be that each āEntityā is just a list of āComponentsā which on one hand define what the Entity can do (like if(entity.hasComponent(WorldObject.class)){doStuff();}) and on the other hand implement functions for the Entity (entity.getComponent(Navigator.class).moveToLocation();). The Components use āSystemsā that have interfaces and implement common code logic. So the Components can be used with many different Systems to achieve the same basic functionality in different ways.
This system is also quite database-friendly as the Entity is basically just a number pointing at the list of components, that part could be done database-driven. Also, there can be a System class that the Components use that uses a database for e.g. doing map logic (while a simple System implementation might do that in memory).
Btw, jME is BSD which means you can use it in commercial projects. This is not the case for GPL which basically forces you to make software you based on such libraries GPL as well (this is not the case for LGPL).
Cheers,
Normen
Hey, thank you so much for your response. I have to say that I was eager to see any reponses for a few days, but for some reason there were none and yet you posted 2 hours after me; I feel free to deduce that I was seeing some kind of outdate copy of this thread although I did use F5 and cleaned cache several times during the period
Iām not sure how to present the code, thereās some code done true, but I feel that itās somehow a mess, such that you would need this project to be working in order to use it to āreadā (understand/parse) the code that makes it, or yeah you could use eclipse and F3 on identifiers and move around like crazy
Like, imagine a program where each identifier would have a random name so you wouldnāt know what itās supposed to do by deducing/assuming from its naming. You would use eclipse/F3 to understand the program or such, and you could understand it. This is how I expect this project to be for someone that knows nothing You just start at some point and you can understand from there and parse the entire system/subsystems and still understand all.
(i read your post about what you said and I will have to reread it since I didnāt understand it the first time or: if I didnāt understand just one part of the one hundred parts, then I completely dismiss it as not understood )
Ok, I will try to explain what Iāve got somewhat figured out so far, or what my foundation for this project is. Basically I have symbols that can be identified by some means (ie. from within Java they can be retrieved by their ID which can be a String). And these symbols eventually can be grouped in a Set, the set itself is a symbol; well for example couple the setSymbol with each children in set, such as S,A and S,B and S,C where S is the set symbol and A,B,C are other symbols (which can be sets themselves at this layer where sets can be recognized, otherwise at the lowest level they are just simple elemental symbols). At this time Iām not yet sure if thereās a layer inbetween Set and Symbols such that it can hold a tuple(two) of symbols (likely it is but canāt think well now lol). Anyway the idea is that everything (the most basic things) are symbols (nothing is really defined , for example, character A is not symbol with ID āAā though it can be, in order to later define character A, we will associate any symbol (usually a newly created random one) with what we think is character āAā ā¦ lots to say here tho). Anyway, so we have the Set of Symbols (level 3; assuming level 2 is tuple of symbols where you know which symbol is on the first position and which is on the second position in the tuple; and level 1 is just symbols alone accessible via their ID from within Java, they need not have an ID , but this is best to access them from with java only and also have this ID and the Symbol(ie. a long inside the database) associated somehow persistently such that the same symbol will be retrieved when java program is restarted - that is, once symbol was newly created (its long randomly or sequentially allocated) and the ID ie. String is somewhat the same(persistent) in the java program). right so i forgot what I was gonna say lol
So basically there is no real data, really, such as it is in a normal database like int, long, char, string; instead there are only Symbols (how many? infinite? ::)). The you can have a set of symbols defined on top of the tuple level, then on top of set level can be defined a an ordered list. How you ask, define an ordered list on top of the level 3 aka set of symbols level, well, let me think (forgot lol)ā¦
(and I should learn to use paragraphs better :)))
[btw, I usually get lost into implementation, because I cannot allow myself to implement it without doing all checks and making sure some variants donāt escape and such]
So, yeah we can implement a double linked list which inherently holds order, where the main list is a symbol L1 letās say. I totally forgot how I once did it and so I will have to deduce it again right nowā¦ What comes to mind, to specify is that the Set above can contain only unique symbols, no duplicates.
And what isnāt so obvious is that you can find out if the symbol X has a symbol Y (or not) as its pointer, I mean ermā¦ since itās based on level 2 which is tuple of symbols where you know exactly which symbol is on which of the two positions (first, second - or last), then you can know if for example in the set S above, u know that A is part of set S (although A can be part of any other set S2, and even A can be a set itself, that is possible; to note and see here, is that wheather A si part of S or not, is actually asked of level 2 (the tuple level) which is unaware of a higher level 3 on top of it deining sets); so yeah you know that S->A and you also know that A is pointed to by S, itās kinda the same thing one would say, but in implementation we need to hold (in berkeleydb) two databases where S,A is key,data and another where A,S is key,data such that we can search if A is second of S (S->A) AND we can search if S is first of A (A<-S). Well anyway, ignoring that which was likely unnecessarily said, where were we,
yeah well ok, we have L1 which is the symbol indentifying an ordered list, and this would be like level4, this list must be based on lower levels, and so, this L1 can be a set of 2 Symbols, one symbol would be a head symbol and the other a tail symbol, which would each point to the first symbol in this ordered list and respectively the last symbol in this ordered list. Which reminds me that we can build an intermediary level or more, defining pointers based on level3 , such that a symbol can have 0 or a maximum of 1 other symbols in its Set to be considered a null resp. pointer to a symbol. And then we can extend this pointer type, to have it be able to point to children of only the specified Set. Well anyway ignoring that for now, back to list L1ā¦
L1->H1 (head)
L1->T1 (tail)
now, in this respect w/o going further you ask, since L1 is a Set now, which oneās head and which oneās tail, since they are both symbols and weāre not supposed to infer their meaning from their ID (which is maybe String in java), and so itās simple, you make sure that when you create the head symbol for list L1, you also add this H1 symbol in a Set called Heads (this would be the ID, but ID wonāt matter at this level, except that inside java, youāll always refer to this ID when adding new head symbols for new lists, and thus all H1 or heads from all possible ordered lists will be part of set Heads) , and so similarly T1 is part of set Tails, so when you want to know , of L1, which oneās the head, you ask or perform an equation:
L1->X
Head->X
find X, where X would be a common child to both L1 and Head, and also to note that H1 will be uniquely created for L1 such that itās not possible that H1 is used in a different list say L2, when we make L2 we create new (ie. sequence in BDB an autoincremented long like current+1) H2 head for it. And sure we can use H1 in other contexts such as, we want to add comments to what H1 is , we define a system such that we include a phrase and H1 in a set and we understand by that that thatās phrase is meant as a comment for H1, within that defined-by-us-system, w/o affecting the meaning of H1, and similarily as we did here with Head and Tails, in that set weād have Commends pointing to all phrases that are comments, and ToWhats pointing to any symbols that we want to add comments on, or seen as a tuple really, just coupling a phrase with a symbol in this case.
Well, surely in my speaking here I use many assumptions which we may or may not share, and thus making not much sense - tho to me seems real simple.
The idea being, that the lowest element of the environment is the symbol (no more java and stuff, although java coding can be defined in this environment and the editor for it)ā¦
Anyway, continuing, then when weāre supposed to add a symbol as part of this list L1, we would have to have something like a Capsule1, which is a set of like 3 symbols, Prev1, Element1, Next1, (using same thing here to see which onesā which, AllPrevs pointing to Prev1 symbol, and AllElements pointing to Element1 and all elments in all lists, and AllNexts pointing to Next1 and all nexts in all lists - using this to know in this set Capsule1 which one of itās 3 children is the real Next1, AllNexts->Next1
and Capsule1->Next1 and so we knowā¦ (should be obvious but I feel I should say more)ā¦
And so, Next1 would point to the next Capsule2 and Prev1 will point to nothing (ie. a null pointer, if defined on a level3andhalf (between level 3 and 4 or rather a level4 and shift all levels with +1) as stated before) ā¦ and Element1 would point to the real Symbol (which could even be the list itself, or any other symbol even Element1 symbol)
List1->Head1->Capsule1->{Prev1->nothing, Element1->E1, Next1->Capsule2}
List1->Tail1->Capusle2->{Prev2->Capsule2, Element2->E1 (even same element twice np), Next2->nothing}
the ānothingā means empty pointer or it can even point to some Symbol implying NoMoreElements
AllHeads->head1
AllTails->Tail1
AllLists->List1 (even, will be needed)
AllCapsules->{Capsule1, Capsule2}
AllElements->{Element1, Element2}
AllPrevs->Prev1, Prev2
AllNexts->Next1, Next2
so basically we have an ordered List1 with two elements both symbol E1, showing that it can support dups, tho we can define a list that allows only unique elements. So here, weād need to think to implement some kind of hooks, to allow or not specified method of .add(E1) to succeed or not, or to call .before and .after somehow somewhere maybe in java so far, and these would allow or not the .add to succeed or not, if ie. list doesnāt allow dupsā¦
Youād say, hard to find element X in the list, need to parse it, but then again
we can implement FastFindOrderedList which is a based on this L1 ordered list system/level
where we have
FFOL1 ā OrderedList1
FFOL1 ā Set1
and Set1 will have all elements E1 that are in the OrederedList1(a list which is same format as L1 above)
and so when seeking element X in FFOL1, we check the Set1 instead of parsing OrderedList1, and soā¦ faster find, assuming Set1 is based on level2 tuple which defers finding to BerkeleyDB or whateverā¦
so much to do and think and so easy it seems
But not sure how to apply those hooks aka rules, and for now it seems they can be make in java code only, and based on this system, we can then make them in the environment as in defined right there in the environment. And then thereās the issues of multiple java threads doing things like read/wring on symbols like that, and need for transations or multiversioning or hybrid of suchā¦ and this also done in java first, or limit java to single thread (even tho it wonāt guarantee consistency yet) and bla bla bla :)))) too much - brain burning :))
Anyway, now I shall reread what you said, maybe I understand itā¦
Yeah, I am kind slow, since I usually refuse to āgetā something if I think there may be too many possible variants to āgetā it, and also when i see generic stuff I need to see examples on it, I think this is quite what the learning system is about ā¦ though being somewhat self-taught Iām way off with how the world normally āworksā :)) [still not saying that I got what you said there lol, I would like need more info about what u said to really allow myself to understand it]
Anyways, BSD license sounds good to me, since I donāt mind people using stuffs commercially - but I do hope this means they have to release the source tho lol, I mean if GPL prevents them from commercially using the codeā¦ and BSD allows , but while both require source releasing ā¦ then BSD sounds better I guess?
Well no idea at this time, anyway hope the ideas (although they donāt seem new really, they just too me! a while to get them) are useful to somebodyā¦ maybe eventually doing more than i could ever do
So if u understood what I said already, about the environment, you probably can see the ābignessā of it lol, I mean it can be used for anything really (as I see it) but especially accessibility to āthingsā like information and understanding how stuffs works, since everything the stuffās made of (or mirroring from irl) is right there explicitly defined and connected with each other, and so Iāve no doubt that if this had a 3D UI and u could see the Symbols in 3D you (anyone really) would understand the concept of how they work (well the computational part is not yet explicitly defined there though, but we should be able to use symbols to defined the coding that uses the symbols like L1 and its children and how it reads them and processes them so that L1 appears to be an ordered list)ā¦
Whatās up world? Gee, I hope nooneās gonna read that garbage Either way, I need a mentor or something, I just canāt do this alone, I seem to be postponing it indefinitely and I am failing to make decisions in due time (they get postponed too).
I would ask for someone to work with on this, but I know yāall have better things to do, so maybe I can ask for someone (thatās better than me, this shouldnāt be too hard, ie. @pspeed or @anthyon etc.) to be like a mentor, to care(about the program) and for me to ask questions when Iām stuck or I donāt know which path to take when about to implement something. I should be able to hack into my subconscious and have it not require that others care, so that it feels empowered to keep working, as if working for those others, but really working for the idea of recognition from others (silly body xD), but I seem to be unable to hack it(neuroplasticity fail), since this requires its cooperation 
and Iām mostly in override mode
I want to do this in eclipse + java + berkeleydb(java edition) + jme3
Iām not really sure what it is or what is going to be, but my aim is accessibility and customizability. I want a set of systems that would make my life easier, easy access to how the system(s) were made (without requiring 3rd party information ie. via searching on google) and all that Iād need to understand and modify the system(s) would be at my fingertips. Sure you could use such a thing to build normal programs if one wants, but maybe something ābetterā would be available like dynamically insert/remove code (sure java could be supporting this already (if it does I donāt know, if it doesnāt then I overestimated its implementation)); well actually if I think about it, any OS already does this dynamic code execution when running a program, but the program instead of if-ing around it could just totally remove that if entirely until an event is happening that will cause it to insert that if back there, or well in that case, the if would obviously not be necessary at all, just the code inside it. Why if when you can event-based insert/remove code dynamically ?
Anyway, my point is, I need a bunch of systems that would take care of quick/immediate accessibility for me. I want to be able to store any type of information, define and redefine live systems, but most importantly give anyone the ability to understand them; why can they understand them? because of accessibility, you know what you want(in order to understand the next part) and you can get it fast, and you can see its limitationsā¦
Somewhere along the line I lost it, anyone interested in this ?
Just scanned quicklyā¦ but if you are considering berkley DB to store what is essentially a graph, you might consider something like neo4j instead. http://neo4j.org/
Their license is not entirely free but free enough for you if you are willing to use berkley DB (which last I checked has an even less free license). Filament, as youāve mentioned interest, is also an alternative but currently requires a separate database (though could easily have an adapter for neo4j also).
But itās definitely some kind of graph that this thread is describing and to try to do it another way would be difficult. http://en.wikipedia.org/wiki/Graph_(mathematics)
Just a collection of related and semi-related links: http://sourceforge.net/apps/mediawiki/filament/index.php?title=Related_Article_Links
Iāll take a look on those, thank you! (I almost posted something from another thread by mistake)
EDIT: wow I just skimmed thru neo4j and it looks like itās god one question though, if I use it, I must release my code under same GPLv3 license as neo4j right? (was previously counting on New BSD license)
I donāt know. If they arenāt LGPL then probably. Thereās probably a FAQ on their site somewhere that addresses that.
For an embedded application without a separate database itās just easier to setup than filament and has had more testing. Filament could probably be made to work with HyperSQL but Iāve never tried it nor do I know if it performs optimally. I should test it someday when I have time again.
Hql performs quite good actually (usually for me faster than a mysql server)
Yes, I know. I embed it in mythruna.
But that doesnāt mean it will perform optimally for graph-style queries through another layer. Iām used to using postgres for this which is a bunch faster than mysql in this case also. I think hsql should perform well here but I havenāt tested itā¦ theoretically it should be the fastest.
neo4j uses its own graph-specific transactional data storage and provides edge locality, ie: constant single hope traversal timesā¦ so for a graph that cannot be fully cached it will win overall. For a graph that can be fully cached, filament is about twice as fast in certain testsā¦ and filament at the time I tested it can hold more cached graph in the same amount of RAM.
@pspeed, I see that you told me about neo4j before here: http://hub.jmonkeyengine.org/groups/general-2/forum/topic/how-to-represent-a-dynamic-tree-of-nodes-in-3d/#post-129322 but although I probably checked it then, I didnāt realize I could use it instead of berkeleydb (or something, since I forgot about it completely).
----
There is a neo4j licensing guide here: http://neo4j.org/licensing-guide/
But I donāt make much sense of it (ie. Iām not that smart) Thing is, Iād start releasing the code on github (from zero since i want to use neo4j now) but I donāt want to go thru the hassle of making sure the licenses are right, so this is basically stopping me from making the source public for now; well I guess I wonāt mind releasing under GPLv3 or AGPL(?) if I would know for sure thatās enough for using neo4j (I could probably even use dual licenses new BSD and GPLv3 but I donāt know seems complicated ). So if anyone knows what license I should put if I want to post the code on github, while using neo4j, let me know 
Looks like I was trying to implement (or rather reinvent the wheel) the same thing like what a graph does, but rather a subset of it only.
I had Symbols to represent the Nodes, and i would use Strings to make sure I have something persistent to attach to them from java (so I would be able to refer to the same Symbol (by name) across application restarts), so just like attaching a "name" property to a Node in neo4j .
But then I would not have relationships as single objects, instead I would always have to use two Nodes to represent a relationship, and there would be only one relationship type: CHILD (and well the reverse relationship PARENT) between two nodes. I understand that in neo4j the PARENT relationship is not needed if I define the CHILD one, as they say it in javadoc... that's even better ;)
And so using only these, I would go ahead and create a Set (based on those), then a Pointer(based on Set) and so on until a double linked ordered list(based on Set & Pointer). And somewhere after this, I got lost/postponed it... but I eventually do have a general idea where I was heading, somewhat, eventually the ability to use multiversioning of sorts to avoid using locks;
===unnecessary babble follows:
The thing is, it seems like I was trying to "create" different relationships by having different nodes be parent of that one specific node where each parent would give that node a different meaning in a different context, depending on who was interested in it.
For example here:
http://i.imgur.com/xXOHS.png
I've defined two sets (set1 and set2, yellow ones) which are each composed of a (pointer to) `domain` and (pointer to) a `set`(the real set)
The node named "A" (the big red one) has 2 meanings, it's both a `domain` and a (real)`set`, but it needs an intermediary node for each meaning(the green and crimson nodes) because when checking what's the domain for set1, if set1 would point directly to A (without an intermediary in between them) then it would find that A's parents has both `domain` and `set`, so set1 would have A as both domain and set, and the same thing for set2.
In this domainset idea, only the program(processor) would be able to enforce that the set elements be a subset of domain and not outside of that domain.
I haven't yet thought how this would look on neo4j, but I will probably edit this when I do.
====
Anyway, I will try to use neo4j now and see if I can recreate all these, or maybe see if I still want to do them the same way... for some reason I avoided having relationships as objects (although i don't remember what this reason was but it seems like a good one at that time I'm sure). And then I'll try to see how can I represent the graph(and levels of it) in 3d using jme3(then I will have to revisit the thread where pspeed told me how to layout the graph so nodes don't stack up), and most likely have real time properties that can be modified from within the 3d which will change how the 3d and graph will be displayed in 3d, potentially having the jme scene backed by the graph that is being displayed (up to a point, as to not cause infinite loop heh)
why use neo4j ?
They are other alternatives that may be better e.g jgraph
Check it if it has all operations you need.
jgraph is graph visualizationā¦ not a graph database.
yeah that jgraph thingy doesnāt seem to be what I want, besides I am really psyched about neo4j and loving everything about it so far, also currently playing this youtube webinar explaining it from like 0, so awesome: http://www.youtube.com/watch?v=UodTzseLh04
I really resonate with it so much, itās like I almost believe that me and it are the same entity
Hehehā¦ well, remember, what you are discovering is āgraphsā. Neo4j is just your entry drugā¦ they didnāt invent the idea. Itās just one of the easier ways to get started.
yeah, graphs but also how neo4j is handling them from java is pretty cool: transactions and traversers and you know, this neo4j+graphs combination is awesomeā¦ now, noone seems to have done a jme3 graph visualization tool I know youāre busy, but youād be the perfect one for the job just saying, otherwise Iāll get there somehow, slow but fun
Traversers are sort of part and parcel with graphsā¦ I actually like the way Filament does traversals better, but Iām biased.
I have no time to make a graph visualization in JME, unfortunately. Iāve written a few graph visualizations already in my lifeā¦ so I donāt feel a strong itch, either.