Slashdot Mirror

Every new requirement to punch data into some dashboard or portal reduces a professor's time to teach. Yes many are bad -- they will continue to be so. But the good ones are already good, and this will just waste their time.

...which is why good anayltics gathers the data for you and does the analysis. Trivial example: Auto Multiple Choice is a piece of software that generates multiple-choice question papers for you, then marks the completed papers and generates individual feedback sheets. It also generates a CSV summary of correct and incorrect answers. Whenever I've marked tests by hand, I haven't had time to capture that sort of detail, so at the end of the process I only have a very fuzzy idea of what my students had difficulty with. Using AMC is quicker than manually marking and gives me useful data. Of course, I'm not a fan of multiple choice, but this sort of information is especially useful.

It can be very difficult. My scientific plotting package, veusz, was written using Python and Qt, so it should be easily portable. However setting up a sensible developer environment on Windows to compile the Python C extensions was a nightmare.

I would love if you would expand on how you did set up. I'm working on a small Python / Qt (pyside) application that I would love to make available, but I would need to know how to create a Windows installer. I do have other open-source software on Github, by the way, but it is all libraries.

It can be very difficult. My scientific plotting package, veusz, was written using Python and Qt, so it should be easily portable. However setting up a sensible developer environment on Windows to compile the Python C extensions was a nightmare. Windows is pretty developer-hostile if you're used to Linux. Trying to find and install the correct version of Visual Studio Express was difficult. I had to learn far too many things about the registry, DLLs, building installers, etc. Mac OS X was rather more difficult, however. You have to download the massive Xcode and the non-standard way that Mac OS packages executables and libraries was very difficult to understand. It took a long time to get fat binaries working.

You do get a different class of user on Windows and Mac OS X, however. The Linux people are closer to being knowledgeable about development, whereas Windows and Mac OS people are primarily users, wanting more help and hand-holding.

Do you have access to an IMAP mailbox? I've started using feed2imap - http://home.gna.org/feed2imap/ (use IMAP on Gmail for more entertanment)

Alternatively, as a lynx user, you may like Snownews - https://kiza.eu/software/snownews/ - its a text-mode rss reader.

I highly recommend turning your RSS items into emails. You can then read them from any IMAP client (or via webmail), and you get synchronization for free.

There's at least one web-based service that'll do this for you (feed2mail), but I've had good success with running feed2imap as a cron job.

(Disclaimer: I wrote my own feed2imap-like tool, which is what I'm actually using now. It's not ready for public consumption, though.)

I haven't tried to code something like this, but you should check out how Veusz does it, because it works perfectly.

Did you look at the list of files?

Yes...

libgnustep-base-dev clearly includes files like NSObject.h.

So? NSObject.h is part of the Foundation framework. It isn't part of the Objective-C runtime. The relevant headers are things like objc.h and runtime.h. The relevant library is libobjc.so.

Unless Debian went out of their way to write their own shims to reproduce the functionality of the GNUstep runtime based on the GNU objc runtime (which uses Object instead of NSObject), it seems far more likely to me that the GNUstep runtime is included in the libgnustep-base package

Uh, what? That doesn't even make sense.

Both runtimes can co-exist just fine, to the best of my knowledge.

Not linked to the same binary. They implement a largely overlapping set of symbols. Linking both causes massive breakage.

But first you should make sure you're correct, because, as I said, it seems extremely implausible.

Look at the source for the GNUstep runtime. Now look in the Debian package. Note that it is not there. Perhaps you should actually check that you know what you are talking about before being patronising.

I should possibly mention that I am the maintainer of the GNUstep Objective-C runtime, so there's a pretty good chance that I know what I'm talking about...

Please don't confuse GNA with GNAA.

The code is here. The AST / back end are in LanguageKit, the Smalltalk front end is in Smalltalk (this also contains a few support things that make OpenStep classes look a bit more like Smalltalk-80 ones). The JavaScript-like language is in EScript, but it may not be working at the moment. It currently requires a trunk build of GNUstep libobjc, but I plan on releasing 1.6 of the runtime Real Soon Now.

I periodically write things about it on the Étoilé blog. You can also read some slightly out of date slides from a talk I gave about it at FOSDEM in 2009, and some more current ones from ESUG this year. Drop me an email if you've got any more questions.

If this is an accurate sample of Wesnoth then I have to respectfully disagree. It might be above-average quality for a C++ application, but plenty of middleware libraries are of much higher standard.

For future reference, filing bugs in a project with an unrelated entity generally does not achieve anything...

This seems to be a change that Richard introduced in GNUstep while shuffling around the headers. The real fix for it is to stop using the GCC Objective-C runtime (which lacks features, is buggy as hell, requires a huge pile of hacky work-arounds for basic stuff to work, and is not supported by Etoile). That would mean you'd be getting the original version of that header, rather than the version in the compatibility lib. Ideally, also stop using GCC, which is a painfully archaic Objective-C compiler and lacks support for most parts of the language, and is also not supported by Etoile. You can't use blocks if you compile with GCC, which I'm pretty sure means EtoileText won't build.

Of you'd read the INSTALL file then you'd have seen this:

* LLVM/Clang 2.9 or higher is required to build Etoile
* libobjc2 1.4 (other ObjC runtimes such as the one packaged with GCC won't work)

So, trying to compile it with GCC and using the GCC libobjc is most definitely not something we support. We're a small project, and don't have the time to spend hacking around limitations of badly designed compilers.

• XHTML, generated by some code I wrote, with hyperlinks and cross references and semantic markup in the code listings generated by clang for [Objective-]C[C++].

In the process of compiling this on Fedora 15, I raised bug 728744, and worked around those problems. The compilation of ETClassMirror.m failed with "incomplete implementation of class ‘ETClassMirror’ [-Werror]". I'm tempted to leave this for now, as this doesn't seem sufficient reason to learn Objective C, and I have other things to do.

XHTML, generated by some code I wrote, with hyperlinks and cross references and semantic markup in the code listings generated by clang for [Objective-]C[C++].

The problem is, with an URL like that no jaded /.er will click that link!

My fourth book (Go Phrasebook) is due to be published soon. I send 3 copies to the publisher:

• Print, PDF, generated by pdflatex. Black and white with crop marks.
• eBook PDF, generated by pdflatex, with cross-referencing hyperlinks and colour for the syntax highlighting.
• XHTML, generated by some code I wrote, with hyperlinks and cross references and semantic markup in the code listings generated by clang for [Objective-]C[C++].

The publisher can then just tweak the CSS for the ePub (XHTML) version. A C code listing has lots of span tags marking words as keywords, typedefs, macro uses, variables, and so on. How these are presented is controlled from the CSS, as is all of the rest of the styling.

The important thing is to make sure you separate content from presentation. If you use a lot of TeX markup in your chapters, then it's hard to use anything other than [La]TeX to typeset it. If you use simple semantic markup with all of the macros defined in a document class, then you can parse the same markup easily with something else and then transform it into some other format.

You could use some sort of XML and generate TeX from it, but typing XML is horrible. I like to work in vim, and with a couple of macros entering LaTeX is really easy.

If you find matplotlib hard, try my Veusz python plotting package. It has a GUI you can build plots within. It is scriptable in python, and even the saved file format is a python script to generate the plot. It can read a variety of data formats.

Subversion repository. Note that it's designed specifically to do stuff in the background for libobjc2. It only implements a tiny subset of the libdispatch functionality, and not as efficiently (one thread per workqueue, for example). It's not intended to replace libdispatch, just to let me use some of the libdispatch APIs in code that has to be portable. The 'toy' in the name is not self-deprecation, it's an accurate assessment.

Oh, and you get better results if you search for 'toydispatch' not 'linux toydispatch' (it's nothing to do with Linux, although it should run there).

If he's missed the opportunity, can I plug my software instead? :-) Hey, great scientific plotting package, Veusz!!! Get it while it's hot.

Surely IDE devs and bugtracker teams could build a decent abstraction layer so that any DVCS would work just fine with them.

Meet DVC...

Sourceforge
Gna!

What sort of plotting do you do? Can you give me some idea of what the most useful plots missing from Veusz are? I know it doesn't do 3D plots, but I don't find them generally useful (except for volume renderings, etc.).

Veusz, my scientific plotting package, is up to revision 1009, and I'm virtually the single author and a volunteer. It has been in development since 2003. The output, IMHO, looks quite a bit nicer than PLPlot.

There was a conversation about this last month on the FD.o mailing list

> Mark Seaborn wrote:
> > I have written a hack for Gtk which replaces Gtk's usual file chooser
> > with a file chooser implemented in a separate process.
>
> Nice, this could be useful. I'm not sure yet if there is a concise
> in-process solution. If not, I'll have a closer look on your code.

The current version is an LD_PRELOAD library that replaces some Gtk
API calls. It works with a lot of applications, but not with Firefox,
which dlopen()s libgtk. The successor is a work-in-progress; it's a
patch to Gtk, which you can find here:
http://repo.or.cz/w/gtk-with-powerbox.git (code)
http://plash.beasts.org/wiki/Story20 (notes)

The intention is that the Gtk code will be separate from the RPC
mechanism used, which is implemented in libpowerbox, of which there
can be different implementations.
For example, there is a DBus implementation:
http://svn.gna.org/viewcvs/plash/scratch/powerbox-dbus/
and the intention is that there will also be a version using Plash's
object-capability comms protocol.

Maybe I should rename libpowerbox to something more descriptive such
as libtrustedpathfilechooser (that's a bit long-winded though).

> Is there a chance that you'll give me permission to "reuse" your
> code under the terms of the MIT-License?

I'm open to the idea of relaxing the licence, but which bits of code
do you have in mind? The Gtk hooks are quite Gtk-specific.

Mark

I hope that it happens, too.

Also don't forget that Sourceforge isn't the only place to find Free Software projects. A lot of us use GNA for our hosting, since it isn't quite so cluttered with ads and the entire platform they use is Free Software, so if we decide we don't like them we can move to our own server somewhere without changing the server-side components at all (GNA is run by FSF France and bandwidth is donated by the French ISP Free.fr).

A good place to look for getting involved with projects is in the bugs database. Pick a bug, and see if you can reproduce it. Then see if you can narrow down the cause and produce a minimal test case. Then see if you can work out which bit of the code is causing the problems. Even if you don't fix it yourself, this information is helpful to the project and a really good learning experience since it forces you to read and understand other peoples' code. And if you fix the bug, most projects will be very happy.

One thing to note is that most projects have their own set of coding conventions. If you send a patch, please observe these. I contribute to a couple of projects which have almost the exact opposite set of coding conventions and sometimes it's a little hard to remember to switch between them, but it's worth doing because it does make life easier for people reading the code in either project.

Emacs 22 does antialiasing. As for distributed VC, How about this?.

To be fair, this is all from minimal use. Most of my day-to-day programming is in one of a few IDEs.

There's Tuxfamily http://www.tuxfamily.org/en/main and GNA on http://gna.org/

Take a look at Veusz if you want proper scientific charting on Windows, Linux and MacOS. [plug]

https://gna.org/projects/unrar/

Better yet, try clive.

• app icon (perhaps could be integrated with/translated to the f.d.o. systray standard)
  
• the work it takes to set up GNUstep just to launch an app (e.g., setting up paths -- thankfully handled transparently in my Gentoo setup)
  
• incompatibility between GNUstep services and dbus, etc. etc.
  
• non-standard build system (still easy enough to making into ebuilds/RPMs/etc.) and monolithic libraries

I think you're confusing the concept of "life" with the concept of "consciousness." Those two things are not equivalent. Computers are already arguably smarter than the common cold, but they are not "alive." The cold virus is alive.

I think nanites are closer to achieving this than anyone constructing AI simply because the two goals are different. The goal of nanites is closer (or the same as) achieving what we would call life. The goal of AI is (as the name suggests) intelligence.

There are some things in between like virtual life...

http://gna.org/projects/dna/

You remember correctly, and it's already there: http://svn.gna.org/viewcvs/gnustep/tools/pbxbuild/ trunk/

I see that either the creators haven't quite grasped the finer details of version control yet, or they're hoping other people won't. Unfortunately, they appear to be wrong...

Hint: svn co -r581 http://svn.gna.org/svn/libsecondlife/trunk libsecondlife

Disclaimer: In addition to being opinionated, I've used Xen and VMware in an attempt to deploy an ISP hosting environment.

Actually, the guest OS can very much benefit from being cooperatively virtualized.

A lot of realtime code is run along side the kernel under a rudimentary hypervisor (Google for nanokernels, Adeos and RTLinux do this sort of thing). In this very important case, it is usually quite a pain to require the OS to have to implement the infrastructure to support emulated devices when it could be using a hypercall infrastructure like Xen. The real potential isn't the gigabyte-sized general-purpose OS guests, it's the 40 kilobyte realtime handlers.

If you're running VMware to run some Windows terminals under a beefy Linux box, that's great. It's an important use case.

However, in addition to this, Xen caters to situations with tiny realtime handlers running along side the a larger interface OS. Little dedicated systems controlling things like Avionics, X-ray equipment, or tracking systems. Xen is an architecture for revolutionary new systems. VMware is a crutch to prop up existing systems, and VMI is designed to efficiently implement that crutch. I don't want to take away people's crutches, I just don't want to impede the revolution.

In my case, specifically, the combination of Xen, a SAN, and CLVM has been consistently less trouble, less management, and higher performance than anything we achieved with VMware. Considering my development partner is a VMware dealer, you can bet that we exhausted their possibilities before diving into Xen. The Xen architecture has simply been better for my purposes.

If you desire to have any real understanding of the issues, take a look at the VMI spec and then the Xen Hypercall docs. Note the proliferation of x86 instructions and constructs in the former and the clean implementation of abstract interfaces in the latter.

VMware is designed to do literal translation of instructions that are pretty much architecture specific. This is because that is how they virtualize--by instruction trapping and translation. The VMI is effectively defined in terms of fencing off x86 specific instructions, memory management, and certain IO. The idea is that everything "dangerous" is trapped and emulated.

The Xen hypercall interface, on the other hand, is much clearer and targeted at actually developing towards it somewhere above a machine code level. Rather than just providing mitigation for basic instructions and processor architecture, Xen provides an hypercall layer and abstractions of pagetable maps / IO that are not nearly as architecture specific. In Xen, a single priviledged domain is allowed to do the dangerous stuff (think kernel-space / user-space split) and an efficient, set of interfaces is used to selectively provide those services to the subdomains.

Of course XenSource and VMware can't agree. VMware doesn't want to have to use abstractions when their selling point is sandboxing binaries. XenSource doesn't want to compromise a good architecture for hardware partitioning just so that a commerical vendor (with sharing issues) can implement a simple meat grinder to churn native code into sandboxed code backed by their clever emulated hardware devices.

Silly Historical Note: If you have enough history under your belt, the VMI might remind you of the architecture behind the Windows NT compatability layer to run NT code on the DEC Alpha processor. The Xen Hypercall system will likely remind you of the architecture of the kernel-space / user-space split among Unixes. If you recognize these, I'm sure you remember which one was a solid, successful product and which one was a buggy source of enterprise-level headaches.

Um...and just WHY would anyone be interested in downloading any of this non-free garbage? Especially Sourceforge. That was one shameful decision. One shouldn't even consider using it over free projects like Savane, GForge, or as someone already mentioned, Trac.

This is Slashdot, after all, did we forget?

Okay, sorry, Last.fm is kind of free, but still they need to restore the ability to play an mp3 stream with the player of your choice, not just their clunky custom software.

heh, well then, http://gna.org/projects/bake.

It doesn't really have documentation, and what docs I have are on a server that isn't functioning right now. But if you want a "living manual", I'm dylan in #ccdevnet on freenode.

Now if you need hard realtime capabilities, neither.

I can very much recommend Gna!. They are fast, they are secure, the site is well maintained and the developers are very responsive. You have choice between SVN, CVS and Arch, backups exist, you can host files and a homepage, ...

I host more 10 projects there since when Gna! first appeared two years ago.

Sorry guys but SourceForge is not an open source project. It's been proprietary for years now. It's development was picked up at https://gna.org/projects/savane .

First, the way the interface looks is irrelevant. A GNUstep theme engine is available here. There's a nice theme in progress called Nesedah (mockup and screenshot of IRC client along with OS X comparison shot)

Second, why is this such a big deal? Don't QT, Visual Basic, and Delphi provide the same RAD approach? No. I've used all of those tools and they just don't stack up. QT is about as good as you're going to get out of a static compile-time-oriented C++ approach. But it's not as simple or direct as a runtime-oriented OO solution like Smalltalk or Objective-C. This is the power of Cocoa/OpenStep/GNUstep.

Delphi, .NET, and QT GUI designers focus on generating code. This is cumbersome and brittle. But Apple/NeXT's Interface Builder and GNUstep's Gorm take a different approach. They actually instantiate objects, set state, create inter-object connnections, and then persist the in-memory objects to disk. When your application is loaded, these objects are unarchived and your application connects to them. This prevents the OO-mocking approach of subclassing a Window class just to create your own instance--something that always makes me laugh but is ubiquitous in the Windows world and has been blindly copied by KDE and GNOME.

Finally, the poster is not a native speaker of English and clearly was not able to convey the sense of humor intended.

Here's the latest Camaelon theme engine. There's a really nice theme called "Nesedah" out there.

Given that NeXT was BSD based, that certainly would complete the clone...

I agree with this point given that GNUstep is the "other" GNU GUI next to GNOME but there are a few hangups that need to be resolved:

1. Apple has added "Objective-C++" to GCC but there appear to be problems using this outside of Darwin. (Ojb-C++ reportedly adds a few handy C++ routeines to Objective-C and it worth looking at.)

http://www.gnustep.org/resources/documentation/Use r/GNUstep/faq_1.html#SEC10

2. Problem 1. appears to be preventing Apple's KDE-based WebKit from being supported on GNUstep. Even though the first web browser was written on NeXT, GNUstep does not have one, limiting its functionality to put it mildy. For more info:

http://home.gna.org/gswebkit/

From there, it does not appear that OO.o will run on GNUstep, limiting its functionality to say...

I suggest anyone interested in this to try the GNUstep live cd. http://www.linuks.mine.nu/gnustep/

At one point the suggestions page included a request to use FreeBSIE... thus seconding your suggestion.

Michael.

OTOH this means that WebCore changes are hard to port to KHTML, but OTOH porting WebCore to GNUstep is easier, I suppose, since most Mac APIs are more or less the same there.

The Objective-C++ bits are actually making life difficult as far as a WebCore -> GNUstep port goes. Progress had gotten petty far but last I looked it wasn't really going anywhere. Browsing the CVS repository the most recent revisions are about 9 months old. On the plus side, when i tried it, it was pretty impressive. Drop a controller on a window in interface builder and write a line or two to send it to a page. it rendereed, clicking on links and stuff of that ilk tended to throw exceptions all over the place though.

Linky: https://gna.org/projects/gswebkit/

I would recommend my own program Veusz! It is written in Python and is designed for publication-quality output. It doesn't do 3D plotting however, but I think the user interface is quite nice.

Jeremy

pychart it is pretty easy to use and makes excelent charts and graphs.

No, perhaps you could try googling when curious.

Hi,

If you want to make some good looking 3d game i might sugest soya. It is a library for python wich is quite easy to learn.

http://home.gna.org/oomadness/en/soya/index.html

When i tried i was able to some good looking demos in a few hours.

It is not suitable for professional games but is perfect for your situation.

btw it runs on windows macosx and of course Linux.

Nigral

The Savane project is another SourceForge-based product. It's what's currently powering Savannah, and it features MySQL compatiable, localization, and a simple setup and configuration system. Although it lacks some of GForge's featuers, most of the same functionality is there and Savane is, IMHO, easier to setup on systems when you can't use apt-get to install gforge. It's definately worth a look.

You could want to install/use Backbone or Garma, which are GNUstep-based Desktops...

Reliable Software makes a product called "Code Co-op: Server-less Version Control", (free trial, then cheap licence per seat) designed exactly for distributed closed-source development, especially where there is no central server. (I have never used it, but I came across their site more than 5 years ago when looking for good windows programming info, which they still have - also cool scientific programming info.)

That said, there's nothing you mentioned that you cannot do if you rent a *nix box and install alexandria, which powers sourceforge or Savane, which powers Gna.org, LCG Savannah and GNU/Non-GNU Savannah

It requires every recordable medium to have a special kind of 'tax' which is divided among copyright holders.