Safara project: results, personal experience and future directions

Hi Squeakers,

The Google Summer of Code period is over and I'd like to spend some words about the project I was involved in, Safara, a text editor for Squeak . The results obtained (from a project and a personal perspective) and what we still need to do is the gist of the post. If you are interested in knowing what Safara is look at squeak-source or in the blog archive.

Results

First the bad news: Safara is not ready to use yet. It needs more
major features (like undo, completion, search/replace, templates) and
it should be a little bit faster (though some steps in that direction
has been already made). Safara is a big and ambitious project so I
expected this situation.

Then the good one: Safara is extensible and easily portable, so the
main goal of the Summer of Code project has been achieved. I am quite
satisfied about the design decision we took. Also the code quality
should be quite good as stated by SLint.

My first true Smalltalk Experience

Safara was the first (real) Smalltalk project I was involved in.
Actually I decided to join the Summer of Code with the Squeak Org.
because I needed an opportunity to improve my Smalltalk skills. You
can never learn a language without writing a big (roughly in terms of
number of lines of code) software. Playing with morphic toy examples,
developing little seaside apps or just copying some examples from a
book can be enough to learn the language and some good code styling
convention but not to really understand how the language can help you
in modeling the problem you want to solve. IMHO.

After three months of full time development with Squeak Smalltalk I
changed my mind about Smalltalk, and maybe Smalltalk changed a little
bit my mind about programming. Maybe now I am a better programmer also
when I develop with another object oriented language.
I was impressed by two aspects.

Smalltalk snippets of code, intended as the real lines of code you
write, are really simple and clear. The consequence is that when you
develop in Smalltalk you put your focus more on the whole design of
the software, and less on the single line of code.

Again, as the syntax rules are simple and the whole environment is
object oriented you have really powerful tools that helps you to code,
as the linter and the refactoring tools.

I also appreaciated the image-based style of development but I was
already used to it, so I got less surprises and I just enjoy my self
playing with inspectors and debuggers, modifying my application when
It is live and running.

Next steps

I have a short to-do list, whose outline follows. We need to run a code
coverage analysis, and write more tests to fix some bugs (mainly
related to command extensions and text presentation). We also need to
refactor the context menu (the one usually triggered by a right
click), in order to allow extensions like completion, spell checking
and so on.

I am still working on Safara but obviously putting less effort than in
the Summer of Code period, as I'd like to bring a new editor to the
Squeak community, or at least an alpha version before Christmas. I
don't want to release too early as I think it can be a bad advertising
for the whole project. After the first release It will be important to
create a community around Safara, with a website, a bug/issue tracker
and so on. At the moment the development mailing list is enough.

So if you are interested in the Safara project stay tuned and look at
the squeak-dev and the squeak-announcements mailing list.

Smalltalk and FreeCAD/Croquet

I’m writing this article not only to fulfill the requirements of the Squeak Organization but also to remind myself how pleasant it is to be programming in Smalltalk. I have always liked computers and always did want to learn programming but never had the opportunity to do it right. There was always the complication factor and other obstacles such as the scarce availability of resources to me but the emergence of the internet age change that. I got serious with programming while doing my pre-u course in college. As with almost everyone else, I started with C and over the years, I did C++, VHDL and Java. Nothing really came out of it until I did my final year project with my mentor Dr. A.S. Koh. I was introduced to the world of Smalltalk and I had a goal which was to create a full fledge CAD system in Croquet and the journey begins.

In my short year of experience with Smalltalk, I find that it has really helped simplify a lot of things that were cumbersome or complicated in the other languages I have learned. The point that Smalltalk is purely object-oriented already makes it’s code more reusable and implementation a lot simpler. For my project, I use the Squeak implementation of Smalltalk and being open source, Squeak has a lot of good and usable classes already incorporated. I just had to work with them to get what I need.

Another thing I like about Smalltalk is the ability to just pass objects around without the need to stick to strict rules for types and all. This has made my working with Smalltalk very easy and reduces the time needed for debugging. I would not even want to think how to do the same things I have done in Squeak in the other languages I have learned. It would be a total mess and I might not have achieved this much in the same time frame.

Besides that, working with the Squeak tools such as the inspector, explorer, class browser, etc.. has been a great experience. It somehow gives me a feeling that the classes and objects actually have some sort of physical form that I can dig in to and understand properly. It saved me a lot of time considering the fact that I did not need to draw diagrams and charts to figure out the structure and flow of my project. It can be done there and then. Speaking of that, the late-binding characteristic of Smalltalk gave me the edge in debugging and testing.
Since this is a short write-up of what Smalltalk did for me, I just highlighted the most important points that came to my mind. Of course, the advantages of Smalltalk is not only limited to the few that I have mentioned. If you are reading this and new to Smalltalk, I would very much like to encourage you to try it out yourself and hopefully, you will feel the same way I do for this beautiful and versatile language.

Future of FreeCAD/Croquet

I have been working on porting freeCAD to Croquet for about 15 months now. A lot has been done and the base of the porting can be evidently seen and used in the current releases but this is just the tip of the iceberg of a somewhat adventurous career pursuit I have chosen. I have chosen to dedicate my first few months since graduating into developing FreeCAD/Croquet rather than joining the corporate world.
If all goes well and my mentor is able to secure funding for our project, a lot of features will be continually be developed and added into it.

Up till this point of writing, FreeCAD/Croquet is being developed in Cobalt and is able to draw basic solids and do simulation. Future plans will include doing Boolean operations for the solids. This means that we will be able to add and subtract solid shapes to and from one another. It will definitely be a great feature since we are aiming to develop FreeCAD/Croquet into a full fledged CAD system.

Other than that, I plan to complete the motion simulator in the near future so that it is useable like freeCAD with the added advantage of being in a collaborative virtual environment. Engineers and educators alike will be able to use it for work or educational purposes. All these will be free to the public too and anyone can download and use FreeCAD/Croquet.

We have generated quite a lot of interest among fellow enthusiast and our next project should be to create an importer for Google SketchUP models. This will allow users to import millions of models available in Google’s own 3D warehouse for use in FreeCAD/Croquet or even in Cobalt itself. If we manage to complete this, it will draw more attention from other communities into the work we are doing, into Croquet and into Smalltalk. It should be a boost for the Squeak and other Smalltalk communities alike.

Besides that, I hope to be able to put FreeCAD/Croquet online as a virtual world with accessible links to the public. Anyone can connect into it and each player would have their own avatar and virtual space allocated. This way, we will be able to achieve one of our goals which is to have FreeCAD/Croquet be used as a content creator to create objects in the virtual world.

Finally, I would like to express my gratitude to all those who have been directly or indirectly involve in making this project a success. It would be great if more people could help with the testing and debugging as it will definitely speed things up and help make FreeCAD/Croquet more user friendly. I will continue to put my heart into making all the plans work out nicely and hopefully, we will be able to see a full fledge CAD system in a virtual world very soon.

About FreeCAD/Croquet

For GSOC 2008, I worked on FreeCAD/Croquet building the graphical interface and 3D solids. FreeCAD/Croquet is meant to be a content creation tool in the collaborative virtual world Croquet. It is based on freeCAD by Dr. A.S. Koh and currently runs in the Cobalt version of the Croquet system. When completed, users will be able to create 3D models in a virtual world, simulate them and share it out to other users in real time.

One of the features that was added in the course of this program is the interactive tree view menu. The tree displays assemblies, parts, markers, etc. It can be used to select the objects in the world and also to bring up a menu by right clicking on the selected item. Some keyboard functions have also been added in for better avatar navigation control and view adjustability.

Besides that, I have added in a lot of windows that allow users to operate on the objects that are created. For example, there are windows that allow the user to change the properties and position of the drawing and 3D solid, window for animation, window to adjust rotation, etc. Click and drag functions were also added in for easy manipulation of the solids.

Other than that, the 3D models were broken down into separate faces and each face is contained in its own frame. This way, individual faces can be selected and manipulated. One example of this usage is the ability to add in markers to the face of a 3D solid. The markers will in the future be used to connect joints for simulation.

Currently, FreeCAD/Croquet has the simulation engine built into it and can do some simulation. There are a few demos of simulation done and the videos are posted on YouTube (It can also be viewed here)
The main goal is to port the whole freeCAD which is written in Visual Works to Croquet and my mentor, Dr. Koh and I are very close to achieving that. In the mean time, users can load freeCAD assembly files preloaded with simulation data into FreeCAD/Croquet and run the animation. This gives an idea of what solid modeling in Croquet will be like.

To conclude, I am very happy that I got accepted into GSOC 2008 because it has given me a great experience and also funds to continue working on FreeCAD/Croquet. With the funds that I have received, I will continue working full time on this project for as long as I can. We hope that more people will get interested and contribute to our work or even draw some attention to the Croquet/Cobalt community. Check out my website for future news and release of FreeCAD/Croquet.

SqueakGtk Launcher

I've made good progress :

* there is a new main interface and we don't need no more morphs :D
* Exceptions during the events are handled with a new Exception UI
* A new website : http://code.google.com/p/squeakgtk/
* A new image which autostart the Gtk user interface :p

Week 10 of GSOC - FreeCAD/Croquet

1) What did you do in the past week?
-Grid on sketch board is up
-Joints are ready now for simulation to be added
-Click and rotate around an object is ready(a bit more tweaking left)
-Fixed lost of keyboard focus on world when clicked on tree menu
-New buffered axis for smoother rendering and better looks

2) What do plan to do this week?
-Work with my mentor in adding simulation code

SqueakGtk

I've improved the support of the Omnibrowser tools, the Gtk port support
more events and is more stable :p I've also made a huge improvement
with the events handling it is no more an active waiting loop.
I use a thread in C and wake up the smalltalk process with a semaphore.
So the CPU is no more used at 99,99% by squeakGtk :D

Week 9 of GSOC - FreeCAD/Croquet

1) What did you do in the past week?
-Added new camera controls e.g. tilt,forward,rotate etc
-Added tool to rotate objects around X,Y and Z
-Set up website to publish FreeCAD/Croquet and provide instructions

2) What do plan to do this week?
-Implement a grid plan on the drawing board to act as a ruler and guide when drawing.
-Add the much needed and delayed Joints to connect two markers

3) What can possibly stand in the way of your work?
-Still, 3D transforms are complicated but I'm getting the hang of it

OpenNARS - End of July Status

I've spent the last 2 weeks giving more love to the wiki and polishing what was ported since the start of the project. It was done in conjunction with design and comprehension decisions.

Until now, the main entities are ported as the primitives inference functions that acts on 2 special NARS arithmetic entities (TruthValue and BudgetValue).

What's missing are the inference rules as the glue with the existing entities in particular Memory who is the central class that implements the reasoning process. It has also on its state all the storage entities (NARS Bag) and organize their contents interaction. NARS bags are not only usual collection. They have in this design the responsabilies of pickOut and putIn (driven by a probabilistic selection using BudgetValue).

So here is a summary ot what was done recently:

Wiki

reorganization around the following sections :

Code Section For all code aspect of the port

• Code Browser
  • ajax based - scriptaculous version extended
    • read-only
  • Squeak and Java Doc
    • gives package and class comment
    • shortcut to the last java version, and to the squeak one
  • Java structure and design discussion

NARS Section

• Introduction to the system
  • Architecture description
  • Overview pictures
  • External Links

Blog

A blog to ask questions, relates actuality of the port...

Timeline

Section in relation to the timeline and objectives of the GSoC Prject

Functional test applications

I haven't made a lot of unit tests yet mainly because my understanding of the system was not really clear (until now?). Instead I did two functional test applications (seaside). They allow testing most of the inference primitives methods on TruthValue and BudgetValue. I plan to continue this kind of functional test with the inference rules and if possible providing a seaside application that will do an inference cycle step by step (kind of WATask).

What's next ?

I also had a reflection on how to implement the rule dispatcher and the rule body. Given our objective (mainly syllogistic rules as we deal only with atomic terms), there are not too many classes and methods but they are quite long. The discussion we had with Klaus was whether to dispatch or not :).

The conclusion is to stick to the actual implementation for several reasons:

• Pei wants the code in one place as the NARS is not stabilized yet (AGI research project)
• Refactoring is quite uncertain now.
• Writing rules with Smalltalk ifTrue:'s isSometing's and:[]'s, the code will be quite shorter and so a bit more readable. For instane, see there (the java version is commented below).
  
• we keep our ideas for later. Dispatching would surely making look a bit nicer but it could be worthless if there is a major move (like using prolog - having rule in a declarative language).

So next steps are, finishing and fixing language statement class and subclasses. Then I'll have to port 3 inference classes. I think 3 weeks is reasonable to have the system starting to work as a whole (still far form doing all kind of inference and logic expression). At this time, we'll have to test, optimize the reasoning process and in the same time I'll do seaside interfaces. I also would like to do a screencast with the Java version to show how NARS behave and can be used. I plan to do this tutorial.

That's it for now.

Happy squeaking ;-)

Week 8 of GSOC - FreeCAD/Croquet

1) What did you do in the past week?
-Fixed drawing movement with mouse. Drag and move properly enabled now. Drag and rotate is also fixed.
-Experimenting with camera movements. Tilt, forward, back, rotate are some of the motions enabled on keyboard.
-Added a pop up info board that shows the position of the mouse on the drawing board to enable better and more accurate drawing. Pop up also added to drawing when dragged and moved to show the position of the drawing.

2) What do plan to do this week?
-Finalize camera movement and try to integrate some of it with the mouse.
-Implement a grid plan on the drawing board to act as a ruler and guide when drawing.

3) What can possibly stand in the way of your work?
-No feedback and no one trying out the things I have done puts me in the dark about how user friendly the controls are.

squeakGtk Omnibrowser

I've updated the squeakGtk website look at : http://squeakgtk.pbwiki.com/

Here is the first release of the Omnibrowser with Gtk :


At this time this is only read-only and there is not menu support.

I've solved the problem of the active waiting with a thread in C in which gtk waits
for an event and when there is an event send a signal to a semaphore and wake up
the Smalltalk process, it works but I should remove the Morphs because X events
handling is not thread safe.

I'll create an image without the morphs if it possible...

OpenNARS - Development Progress - 2nd phase

The port of NARS is now getting in the more complex/interesting part ie. porting inference rules and make the whole thing work.

It hasn't been possible to focus on simple inference as there's not a clear distinction in the rules implementation. So I did choose to port the maximum I could understood. Most of the stable classes that are not evolving much are ported. Some are tested, some are not as I need other parts to make them work.

We had also a discussion with Klaus to agree on the objectives and ways to tackle some problems. I also had to read again documentation on the NARS approach as it's still difficult to me to explain to others. Also, java code is not always explaining by itself :).

I've extended an overview document with picture to explain relation between statement (logic expression), sentence, reasoningItems (tasks that encapsulates sentences, judgment, question goal...) and reasoning artefacts (memory...bags...). See here.

Where I'm right now is thinking about the implementation choice of Inference rules.
Indeed, Pei choose to implement inference rules, as some utility functions and the memory as static methods only in several distinct classes. I understand his choice as it's easier for him to find and modify them (java world), but this is another difficulty for me to understand the system. It's therefore kind of mixed because several methods should belong to others objects and so, hard to port as I ask myself whose object responsibility it is... I've started that for all Utility functions (that are really stable). All three classes don't exist anymore and are either extension method.

Also dispatching them in Smalltalk is less problematic as I can use Pragma or even flags to access them quickly... Besides the static'ness of these methods, I find they are too long... which makes them hard to have a global view. Over the 4 inferences classes (+ a kind of rule dispatcher - RulesTable), there around 10 reasonning method per class which is not much but they are quite long... So fisrt, I'll port skeletton, bypass the parts in relation to complex inference (temporal, structural...) and I'll try to see common parts so as to create convenience methods etc...

That's why I'm spending this week getting a better understanding of the system to propose an alternative design. I think for instance that the memory class is the reasoning controller. It has links to several bags (Nars bags), that are the real storage of the working memory (names can be very confusing sometimes). I find I need some more abstraction and one of them is a reasoning controller which will hold the reasoning process (an inference engine?). I'm also discussing that point with Pei on the Nars mailing list.

The other missing parts is the full implementation of NARS language (NARSESE) that allows to express logics expression (input belief, outputs). I'll focus on implementing first simple statements like "swan is black" "yoyo is a swan" etc... The inference engine would be already usable for more complex expression. Still the future seaside interface will only focus on simple statements, presenting inference and result(s).

To deal with language terms, I may use a visitor pattern, or at least a better dispatch but I'll focus on that later.

So, next objectives are:
-port CompoundTerms, Statements and relations subclasses (inheritance, equivalence, implication, instance...) to be able to express tasks - statement which is a logic statement with a truth value plus some meta information that allow to deal with priority, decay, life of the belief in the working memory ...
-then make NAMemory work, maybe split it into 2 classes. I need to implement inference rules (some not all)

See you all... Feel free to leave comments, give pointers on pattern or application that use rule and inference (SOUL ? NeOPUS ?)...

Cédrick

Week 7 of GSOC - FreeCAD/Croquet

1) What did you do in the past week?
-Experiment with different camera movements
-Implemented keyboard keys with avatar motion e.g. tilt, move around etc
-Experiment with solid transformation, trying to put in better control of solids with mouse movement

2) What do plan to do this week?
-Continue to work on avatar movement with keyboard and applying different movements to have a better CAD view of assembly
-Restructure drawing of solids for better integration with mouse movement

3) What can possibly stand in the way of your work?
3D transform theories are really complicating!!

Safarà status: New commands and a new SATextMorph

These week I added some support to implement commands based on multiple cursors.
As an example I provided commands to move the current point of editing between words (e.g. next-word, previous-word, etc.).

The second issue I attacked was the one related with how present the characters. Now we use a custom morph to present the content of a buffer.

The next step will be to define a GUI-independent model for styles and interactions with ranges of text. This will enable us to provide some features like text-selection, syntax-highlighting or "Do it".

As in the last post and from now on, I will try to provide a snapshot:

Cairo support under SqueakGtk

Cairo is a 2D graphics library with support for multiple output devices. Currently supported output targets include the X Window System, Quartz, Win32, image buffers, PostScript, PDF, and SVG file output. Experimental backends include OpenGL (through glitz), XCB, BeOS, OS/2, and DirectFB.

for more informations go to the cairo website : http://cairographics.org/

The support of Cairo under squeakGtk is not complete but most of the functions are supported, it lacks the support of the transformations functions, ...

May be it will be possible to use cairo for the morphs ?

SqueakGtk status

Here are some news of the SqueakGtk project :

I've extended the Gtk support with new widgets :

• GtkAboutDialog (added some fields)
  
• GtkFontSelectionDialog
• GtkAccelLabel
• GtkLinkButton
• GtkScaleButton
• GtkVolumeButton
• WebKit
• ...

I've corrected a bug with the memory management, it seems that Gtk doesn't like
g_object_unref when there is a parent widget. The support of Gtk
is more stable but there are others problems in the events handling
this is an active waiting so it uses a lot of cpu times, an other problem
is when the user save the image a "Gtk" object in Squeak only contains
a pointer in a C structure and I need to save and restore this structure.

I'm working on the Omnibrowser support and in the improvement of the
new tools :p

Some basic tools :

Squeakzilla a new browser :p

Safarà Status

A first prototype of Safarà is ready at last.

Currently it supports basic ascii text editing, that can seem not so much.

Actually I am really happy for the work done as I think (and I hope) I met several goals:

1. extensibility in terms of features: you can add features (commands gestures syntaxes) to Safarà at runtime, without interfering or having to interact with other layers;
   
2. portability over implementations: the model does not know anything about the UI as they are completely decoupled and communication between them occurs by using announcements. Thus, you can write also a non-morphic UI for example. Just make your UI objects subscribe to the right announce and write a bridge to translate the GUI-dependent events to the Safarà events;
3. Classes and methods are well categorized, documented and tested.
   

So, what are the next steps?

For the Morphic UI: Do not use TextMorph as base class but a custom morph

For the model: Integrate into Safarà some code wrote by Lukas for syntax-aware commands

You can find the latest snapshot here. There is also a developer mailing list, you can subscribe to. As Safarà partecipate to the ESUG 2008 awards you can find additional documentation about the project goals and design here.

For the most curious, this is a snapshot

Week 6 of GSOC - FreeCAD/Croquet

1) What did you do in the past week?
-Created handles to interactively draw objects.
-Handles allows extending and rotating the drawing.
-Putting in markers and selecting them so that Joints can be created and linked to them.
-2D drawing detection to move drawings and to select it

2) What do plan to do this week?
-Will continue work to create Joints that will reference 2 markers for simulation purpose
-Look into how the camera view can be adjusted for better viewing angles. Any suggestions on this is much appreciated

3) What can possibly stand in the way of your work?
3D transformation is quite complex and i'll need some time to understand it better in order to create better functions.

Here's a video showing some of the work I did:

Status

As promised, some news of the project!

So far, the bot framework is on the good way... I tried as much as possible to have an easy public interface so that it should be easy for anyone to develop with the framework. The base is maturing and shouldn't change much in the future.
I've developed some basic functionalities: an administration interface, a help system, a greeting (a bot has to be polite) and a simple infobot that can memorise definitions.

At the moment, the IRC protocol is handled by the existing IRC client in Squeak. Unfortunately it relies on Morphic ( in short; the gui ). I've abstracted it so that the bot isnow completely indenpendant of it. It is planned to develop a clean IRC library which wont rely on any gui.

So what next ?

• Continue the real world tests (yesterday was the first attempt on freenode :),
• Polish the admin and help,
• Add logging functionalities
• Develop a web interface (with Aida or Seaside)
  
• Develop a clean IRC library
  
• Write docs

Stay tuned!
(if you see squeakbot on freenode, introduce yourself to him :)

Squeak - Impressions

Wow.

The more i code, the more i fall in love with Squeak and Smalltalk in general. I've properly started my gsoc project after my last exam (20 June) and i'm already addicted to the different Smalltalk tools. Iknew quite well the classic System Browser but was a little bit intimidated by the other ones.



Little by little, i've started to code in the debugger (i can imagine non smalltalkers shocked while reading this but it _really_ is an eyes opening experience) and guess what...I like it! I've learned to appreciate the refactoring, senders, hierarchy, variables and versions broswers. Most of the modern IDEs have those functionalities but Smalltalk had those for years and they are so well integrated in the environment. All those tools encourage you to explore the image. It feels like reading wikipedia: you start to look at an article about something and link after link you end up reading about the Pyongyang metro...

The only drawback is that you are quickly overwhelmed with windows popping up everywhere... especially on a 12 inches screen :)

Another common problem for beginners is the syndrom of 'Where the hell do i have to start?'. Interesting opinions can be found in the comments of a Ramon Leon's post. Now, there's a fantastic open book that everyone willing to learn Squeak/Smalltalk should read: 'Squeak By Example'.

More news about the project itself very soon!

Week 5 of GSOC - FreeCAD/Croquet

1) What did you do in the past week?
- I have done detection of planes and points on the plane. I can now select a Cube, click a point on it and add another solid on that point.
- Corrected all problems of rendering and picking objects. Had problems rendering and picking objects earlier because of the different coordinate systems used by FreeCAD and Croquet. It took me a while to figure everything out but its all fixed now.
-Completed a window UI to place a solid precisely on a specified point.

2) What do plan to do this week?
-Create more UI windows to manipulate solids
-Enable markers to be referenced by Joints for animation/simulation purposes

3) What can possibly stand in the way of your work?
Nothing much except that my internet connection is no set up yet due to very very slow services by my ISP. Doing online research and replying mails in a cyber cafe nearby at the moment.

Week 4 of GSOC - FreeCAD/Croquet

1) What did you do in the past week?
-Coded in picking methods for cubes and cylinders, not 100% working but I'm able to move things relative to their plane
-Combined all solids under one main class & trying to make rendering more efficient

2) What do plan to do this week?
-Continue to implement the face/plane detection for polygons and ellipses.
-Fix some rendering bugs
-Other minor fixes for better rendering efficiency

3) What can possibly stand in the way of your work?
-No internet connection at my new place yet (still waiting for my ISP)

Week 3 of GSOC - FreeCAD/Croquet

1) What did you do in the past week?
Played with FreeCAD and learning the tutorials so that I can replicate most of the interactive stuff on replicate. Still trying to implement the face/plane detection.

2) What do plan to do this week?
Face/plane detection for the 3D solids

3) What can possibly stand in the way of your work?
I just moved to a new place, trying to settle down ASAP.

Week 2 of GSOC - FreeCAD/Croquet

1) What did you do in the past week?
-Cleaning up some code and solved an initialization problem of the Croquet world.
-Also released a working version of FreeCAD/Croquet using Monticello.

2) What do plan to do this week?
-Implement face detection of 3D solids starting with the cube first.

3) What can possibly stand in the way of your work?
-Might not have enough time because I'm moving to another place this week.
-Croquet keeps crashing on me in debug mode due to asynchronous processes thus slowing down progress.

FreeCAD/Croquet first release

Guys,

I have released the first version of FreeCAD/Croquet (Project that I'm working on).

You can get it here which is the version loaded into Cobalt. After downloading it, launch Cobalt and drag KayefFreeCAD out from the parts bin and it should load.

If you already have a Croquet image then just use the Monticello package. Please follow the instructions in this link on how to install the package.

Once you get that running, follow this link for tutorials on how to use it. Currently, you can create 3D solids and also load sample assemblies. Watch some of these videos too if you have the time.

Week 1 of GSOC

1) What did you do in the past week?
I have already implemented the tree view menu before this but it is not interactive yet. I have just added in a feature that enables the user to select an item on the tree by clicking on it. I have also added a window that controls the simulation of the assembly with options to start,pause and stop and in the same time display the frame rate and a few other info that will be added in time. I have also uploaded my work on Croquet Source but its not quite ready to be installed yet as I still need to configure it to be easily installed by normal users. Should be done in 1 or 2 days.

2) What do plan to do this week?
I will implement the picking and selecting of objects with the mouse pointer and moving them in the Croquet world. I currently have done a bit of work on this but its very buggy with inconsistent results. I will need to fix this and also come up with a good way to move things in a 3D environment.

3) What can possibly stand in the way of your work?
Specifying the TBoundSphere for an object in Croquet seems to be a bit of a problem because it works sometimes but other times it does not. Also, it causes the rendering of the objects to go wrong (occasionally disappearing in different viewing angles). I should study more on this stuff to understand it fully or else the whole click and drag feature will be flawed. Anyone care to shed some light on this?

OpenNARS port to Squeak using Seaside

Hi, I'm Cédrick Béler, a french PhD student and I've been selected for GSoC of squeak. The selected application consists in porting OpenNARS (Non-Axiomatic Reasoning Systems) to Squeak using Seaside for the GUI. My Mentors are Klaus D.Witzel and Pei Wang (creator/developer of NARS).

NARS is before all a reasoning system but a non-axiomatic one compared to usual semi-axiomatic ones we find in AI [1]. It attempts to uniformly explain and reproduce many cognitive facilities, including reasoning, learning, planning, etc, so as to provide a unified theory, model, and system for AI as a whole. The ultimate goal of NARS research is to build a thinking machine. What makes this system different from conventional reasoning systems is its ability to learn from its experience and to work with insufficient knowledge and resources. NARS theory exists. A book has been published recently (Rigid flexibility).

Since 2008, NARS is developed as open source software . A prototype exists in java for the core of the system but there is still a lot to do until the aim of having a thinking machine is reached. A port is underway in Python and we propose to start a squeak port because we think a dynamic and flexible environment and language as Smalltalk/Squeak could be very appropriate here.

Right now, I'm finishing writing my PhD dissertation so I will only spend moderate time on the project in June (delivery date is by the end of June). Once done, I'll be nearly full-time on the project. When coding, I'll be as much as possible on IRC (#squeak) on freenode under the nickname Cdrick. Feel free to contact me if you have any question in relation to this project. I will start the port with the stable core of the prototype (see here for more information)

Cédrick Béler (cdrick65 for my google account...)

[1] NARS (Non-Axiomatic Reasoning System) is a concrete example of non-axiomatic system. Here is a short definition of axiomatic, semi-axiomatic and non-axiomatic (quoted from Pei Wang publications)

1. pure-axiomatic system: In all aspects, the system has sufficient knowledge and resources with respect to the problems to be solved.
• Pure-axiomatic systems are studied in mathematics, and is not directly related to AI
2. semi-axiomatic system: In some, but not all, aspects, the system has sufficient knowledge and resources with respect to the problems to be solved.
• Most of the previous AI work in the inference framework belong to the category of semi-axiomatic system, which attempt to make partial extension or revision of mathematical logic, while keep the other parts.
3. non-axiomatic system: In all aspects, the system has insufficient knowledge and resources with respect to the problems to be solved.
• For AI, what is really needed are non-axiomatic systems, which do not assume the sufficiency of knowledge and resources in any aspect of the system.
  

Basically in NARS, solving the same problem several times has not to give the same solution... If you're intrigued by this theory, don't hesitate having a look at the available documentation :)

Introduction to the Safará project: a Source code editor for Squeak

Hi, I am Luigi Panzeri, one of the five student selected to work for the Squeak project. I have Lukas Renggli as a mentor.

The goal of the Safarà project is to develop an extensible code editor that can improve the DSL experience on Squeak, and at the same time can provide the same features, that come up with modern editors like Eclipse, Emacs and TextMate.

Actually, It aims to provide the following features:

* Highly configurable and customizable using Smalltalk code or a
graphical customization interface.

* Highly extensible in term of features and syntaxes supported.

* Easily embeddable as a widget in other applications (e.g. mail
reader, applications using DSLs, etc.).

* Well integrated with the tools present on a traditional Squeak
development image.

* Support for collaborative editing.

FreeCAD: 3D CAD with Motion Simulation Port to Croquet

Hi,
My name is Phua Khai Fong from Malaysia. I'm in my final year pursuing my electronics engineering degree in Multimedia University. I will be working on Croquet for GSOC and the goal of my project is to create a tool for in-world content creation. Currently, I am able to draw and extrude 3D solids which consists of cubes, cylinders, ellipses and polygons. I will be working with my mentor Dr. A.S. Koh and the Croquet community to add more controls to the content creation tool that I am working on which is also based on FreeCAD (for more info on FreeCAD, visit www.ar-cad.com). If you are interested to see the initial stuff, I do have a few videos online here .

Regards,


Phua Khai Fong
kayef8 [at] yahoo [dot] com

Introduction to the IRC Bot Framework project

Hi all,

I'm François Stephany, one of the five Squeak gsoc students.

The goal of this project is to build a framework for developing IRC bots. At the moment, the squeak related irc channels rely on non smalltalk bots (who said Lisp?) to provide the needed services. As smalltalkers, we like to eat our own dog food and have special needs. A bot written in smalltalk could have some smalltalkish functionalities (explore image, monticello tracking,...) that would be a bit tricky to provide in other languages.
Squeak already has a client: IRCe, it will be used (and refactored if needed) as a starting point.

The basic functionalities:
- channel logging
- channel administration
- pastebot
- storage bot/infobot

If you have any suggestion/wish for the bot, don't hesitate to tell !

See you all on IRC (#squeak)
[nick: fstephany on freenode -- Thanks Randal :]

Introduction to Squeak GTK project

Here is a short description of the Squeak GTK.

This project aims to :

- provide a full support of the GTK+ library included GDK, GLib, Cairo.
- provide a full support of the WebKit library.
- Create a MVC framework
- Create a basic toolset (inspector, reflective management of widget, efficient class browser, transcript, ...) if time permitted

You can find the project at : SqueakGTK

There is a SqueakVM with the callback patch and the SqueakGTK plugin generated. But you can find all the files to patch the squeakVM and build the plugin by hand ;)

Gwenael Casaccio

Google Summer of Code 2008

Hi all, and welcome back to the Summer of Squeak blog!

For the second year, the Squeak project has been accepted into the Google Summer of Code program.

This year we decided to reopen the blog a little earlier, while students applications are still open. So, if you're interested in proposing a project to Squeak, you're still in time!

If you need more info, just head to the Summer of Squeak webpage!


The Squeak Project Mentors