The Perfect Server: Ubuntu 11.10 Oneiric Ocelot With Nginx , Chapter 2.

This tutorial shows how to prepare an Ubuntu 11.10 (Oneiric Ocelot) server with nginx for the installation of ISPConfig 3, and how to install ISPConfig 3. Since version 3.0.4, ISPConfig comes with full support for the nginx web server in addition to Apache, and this tutorial covers the setup of a server that uses nginx instead of Apache.

ISPConfig 3 is a webhosting control panel that allows you to configure the following services through a web browser: nginx and Apache web server, Postfix mail server, MySQL, BIND or MyDNS nameserver, PureFTPd, SpamAssassin, ClamAV, and many more.

If you want to use nginx instead of Apache with ISPConfig, please note that your nginx version must be at least 0.8.21, and you must install PHP-FPM as well. For CGI/Perl support, you must use fcgiwrap. This is all covered by this tutorial.

Please note that you cannot use this tutorial for Debian Squeeze because Squeeze comes with an older nginx version (0.7.67.) and does not have a PHP-FPM package!

Please note that this setup does not work for ISPConfig 2! It is valid for ISPConfig 3 only!

I do not issue any guarantee that this will work for you!

Please check if the installer detected your time zone correctly. If so, select Yes, otherwise No:

Now you have to partition your hard disk. For simplicity's sake I select Guided - use entire disk and set up LVM - this will create one volume group with two logical volumes, one for the / file system and another one for swap (of course, the partitioning is totally up to you - if you know what you're doing, you can also set up your partitions manually).

Select the disk that you want to partition:

When you're asked Write the changes to disks and configure LVM?, select Yes:

If you have selected Guided - use entire disk and set up LVM, the partitioner will create one big volume group that uses all the disk space. You can now specify how much of that disk space should be used by the logical volumes for / and swap. It makes sense to leave some space unused so that you can later on expand your existing logical volumes or create new ones - this gives you more flexibility.

When you're finished, hit Yes when you're asked Write the changes to disks?:

Afterwards, your new partitions are being created and formatted:

Now the base system is being installed:

Create a user, for example the user Administrator with the user name administrator (don't use the user name admin as it is a reserved name on Ubuntu 11.10):

I don't need an encrypted private directory, so I choose No here:

Next the package manager apt gets configured. Leave the HTTP proxy line empty unless you're using a proxy server to connect to the Internet:

I'm a little bit old-fashioned and like to update my servers manually to have more control, therefore I select No automatic updates. Of course, it's up to you what you select here:

We need a DNS, mail, and LAMP server, but nevertheless I don't select any of them now because I like to have full control over what gets installed on my system. We will install the needed packages manually later on. The only item I select here is OpenSSH server so that I can immediately connect to the system with an SSH client such as PuTTY after the installation has finished:

The installation continues:

The GRUB boot loader gets installed:

Select Yes when you are asked Install the GRUB boot loader to the master boot record?:

The base system installation is now finished. Remove the installation CD from the CD drive and hit Continue to reboot the system:

Custom Search

If you liked this article, subscribe to the feed by clicking the image below to keep informed about new contents of the blog:

wxGlade is a GUI designer written in Python with the popular GUI toolkit wxPython.

wxGlade is a GUI designer written in Python with the popular GUI toolkit wxPython, that helps you create wxWidgets/wxPython user interfaces.

At the moment it can generate Python, C++, Perl, Lisp and XRC (wxWidgets' XML resources) code.

As you can guess by the name, its model is Glade, the famous GTK+/GNOME GUI builder, with which wxGlade shares the philosophy and the look & feel (but not a line of code).

It is not (and will never be) a full featured IDE, but simply a "designer": the generated code does nothing apart from displaying the created widgets. If you are looking for a complete IDE, maybe Boa Constructor, PythonCard or Spe(which includes wxGlade itself, BTW...) is the right tool.

The latest official release (version 0.6.3) is rather outdated. If you plan to frequently use wxGlade, it is better to use the latest version in the Mercurial repository.

 Installation and requirements.

Since Python is a pseudo-interpreted language, you don't need any “compile” or “make” steps.
wxGlade requires Python version 2.2 or later and wxPython version 2.3.2.1 or later.
The binary versions are stand-alone and don't have any requirement.

You can download wxWidgets from http://www.wxwidgets.org and wxPython from http://www.wxpython.org.

In Microsoft Windows, you only need to install wxPython. wxWidgets is not required.

In a Linux/Unix environment you need to install wxPythonGTK, which usually also requires the wxGTK package. Mandrake Linux 9.2 comes with a libwxPython rpm that works, without installing wxGTK.

If you use apt or yum, just install wxPythonGTK package, and let it resolve the dependencies.

You need to know the basics of wxWidgets or wxPython, as well as the basics of C++, Python or Perl. You can't use wxGlade if you do not have any basic understanding of programming. You can't learn wx programming from reading this manual either.

Quick start.


We will design a simple form.

Start wxGlade by running the wxglade.py program.

You will see a Main Palette with several buttons, and a Tree Window with an icon marked “Application”. A Properties Window shows the properties of the Application.

If you move the mouse over a button in the main window, a tooltip will display its function.

To add a frame in the design window, from the Main Palette choose the first button: “Add a frame”.

Then choose wxFrame as the base class.

Look at the tree window and see that two icons are generated under the application icon, a frame icon and a sizer icon.

If you double click with the mouse on the frame icon, the designer window appears. Notice that the sizer is displayed as a set of gray boxes: they are the “slots” of the grid sizer where you will place the widgets.

You put a widget on a sizer by selecting it on the Main Window, then click on an empty slot on the frame on the designer window. Try adding a static text, a text control and a button.

If you want to add something else, add empty slots on the sizer by right-clicking on the sizer on the tree window and selecting “Add slot”.

Play around, adding four or five widgets on the frame.

Now look at the properties form; there are three tabs. In the “Common” tab you can specify the name, size and color of the widget.

In the “Layout” tab you can adjust borders and alignments.

In the “Widget” tab you find the properties depending on the widget.

You can select the properties of a widget by clicking on the designer window or the corresponding icon on the tree window.

Try adjusting widgets with the properties form until you know you have played enough.

Now let's generate the code.

Select the Application icon on the tree window and go to the properties window.

Check Name and Class, choose a Top window, check Single file and choose the language and set the Output path by pushing the button for selecting a path and a filename.

Finally press the Generate code button, and the code is generated.
  

Basics of wxGlade.

The program wxGlade is a tool for designing Graphical User Interfaces (GUI).

It is intended to be used with the wxWidgets framework in all its flavors: C++, Perl, Python and XRC.

You use a visual editor for creating forms, menus and toolbars with the mouse.

Your design is saved in a .wxg file, which is the wxGlade file format.

Then you generate source code or XRC by using visual tools or invoking wxGlade at the command line.

You can also use wxGlade in your makefile by generating source code only when the .wxg changes.

A .wxg file can contain multiple forms, panels, menus and toolbars and generate either a single file containing all classes or multiple files containing one class each.

wxGlade does not manage events, file inclusion, function names, stubs or anything else but graphic interface code.

Code generation.

Before we proceed with the code generation, let's save our work, selecting the Save As... item of the File menu of the main wxGlade window: this operation is not strictly necessary, but it's a good practice to not risk to loose the work, in particular until wxGlade will reach a certain maturity :-)
Now we can go on with the code generation: select the Application item on the tree of widgets (it is the root) to make the Application tab appear on the properties window. This panel contains the options for the code generation:

• Name: name to give to the wxApp object which represents the application: if this property and the next one (Class) are not active, there will be no code for the application startup, but only that of the various widgets
  
• Class: name of the class derived from wxApp which represents the application: if this property is not active but the previous one (Name) is, the application object will be an instance of wxPySimpleApp (this applies to Python output only - for C++ output this property must be active if you want the startup code to be generated)
• Encoding: encoding used to store the saved .wxg file (also for XRC);
• Enable gettext support: if checked, all the strings in the generated sources will be wrapped by a "_()", ready for gettext;
• Top window: main window of the application to generate
  
• Code generation: this controls the kind of output, and lets you choose between a single source file containing all the widgets, or a separate file for each custom class defined (for C++ output, the single-file mode actually generates two files, a ".h" and a ".cpp")
  
• Language: this lets you choose the language of the generated code: at the moment, Python, C++ and XRC, i.e. wxWindows resources xml format. Note that in this last case some of the properties of the application are ignored (Name, Class, Top window), and some are disallowed (you cannot set Code generation to multi-files)
  
• Overwrite existing sources: if checked, the code will be completely re-generated instead of updated (see the first note below for details);
• Output path: in single-file mode, name of the output file; in multi-file mode, path to the output directory: in this last case, every custom class will be placed in a file with the name of such class, except for the (eventual) wxApp class, which is placed in a file whose name is given by the Name property described above. For example, for our notebook, we'll have MyFrame.py, MyNotebook.py and app.py (assuming you're generating Python code, of course).
  
• Generate code: button which starts the code generation

Notes.

This section contains a list of things that you should know about wxGlade (known bugs and/or limitations, "hidden" features, tips and tricks, ...) which I wasn't able to fit in the tutorial . The list is loosely sorted by importance.

• When you generate Python or C++ code, if the output file already exists, wxGlade by default doesn't overwrite all its contents, but only the lines inside a

    # begin wxGlade: ...
    # end wxGlade
    

  block. This is a desirable feature in most occasions, since it lets you add your code to the file without worrying of losing it when re-generating the GUI code, but there are situations in which a little attention is required. In particular, you should be aware of the following:
  • If the output file contains a class whose name is the same as that of one of your custom classes, but its body has no wxGlade block, the code for that class is not generated (a warning appears on the shell);
  • If you rename one of your custom classes, you should rename also its code in the output file (and also all the occurrences of such name in the wxGlade tags), because wxGlade has no way of determining the previous name of such class, and will treat it like a brand new one (this means that it will generate a new class declaration instead of updating the old one). Let me explain this with an example:
    Suppose you have a class called MyFrame, and the corresponding generated file frame.py:

    #!/usr/bin/env python
    # generated by wxGlade 0.2 on Sat Dec 14 15:15:06 2002
    
    from wxPython.wx import *
    
    class MyFrame(wxFrame):
        def __init__(self, *args, **kwds):
            # begin wxGlade: MyFrame.__init__
            kwds["style"] = wxDEFAULT_FRAME_STYLE
            wxFrame.__init__(self, *args, **kwds)
    
            self.__set_properties()
            self.__do_layout()
            # end wxGlade
    
        def __set_properties(self):
            # begin wxGlade: MyFrame.__set_properties
            self.SetTitle("frame_1")
            # end wxGlade
    
        def __do_layout(self):
            # begin wxGlade: MyFrame.__do_layout
            pass
            # end wxGlade
    
    # end of class MyFrame
    

    Now suppose you rename MyFrame to RenamedFrame. If you don't care to fix frame.py accordingly, if you re-generate it you will get something like:

    #!/usr/bin/env python
    # generated by wxGlade 0.2 on Sat Dec 14 15:15:06 2002
    
    from wxPython.wx import *
    
    class RenamedFrame(wxFrame):
        def __init__(self, *args, **kwds):
            # begin wxGlade: RenamedFrame.__init__
            kwds["style"] = wxDEFAULT_FRAME_STYLE
            wxFrame.__init__(self, *args, **kwds)
    
            self.__set_properties()
            self.__do_layout()
            # end wxGlade
    
        def __set_properties(self):
            # begin wxGlade: RenamedFrame.__set_properties
            self.SetTitle("frame_1")
            # end wxGlade
    
        def __do_layout(self):
            # begin wxGlade: RenamedFrame.__do_layout
            pass
            # end wxGlade
    
    # end of class RenamedFrame
    
    
    class MyFrame(wxFrame):
        def __init__(self, *args, **kwds):
            # content of this block not found: did you rename this class?
            pass
    
        def __set_properties(self):
            # content of this block not found: did you rename this class?
            pass
    
        def __do_layout(self):
            # content of this block not found: did you rename this class?
            pass
    
    # end of class MyFrame
    

    which is clearly not what you intended.
     
  • If you remove a custom class from the wxg file, wxGlade won't automatically remove it from the source when it is re-generated (this does not apply if there is no old version of such source), but it will try to update the parts inside wxGlade blocks nonetheless: this means that:
    • If you want to remove the class, you have to do it manually,
    • If you want to keep the class as is, you have to remove the wxGlade tags.
  As of version 0.3, it is possible to turn off this "update contents" feature, by checking the "Overwrite existing sources" property of the Application: if the property value is True, wxGlade will always re-generate the code from scratch (performing the appropriate backups, according to the preferences you can set from View->Preferences->Other).
• When you add new custom classes to an app, if there is a previous version of the generated code, the definitions of the new classes will be inserted *before* the old ones: this usually is not a problem, but for C++ output there could be occasions in which the generated code won't compile "out of the box", but you'll have to perform some manual adjustments (e.g. add some forward declarations before the new classes).
   
• When you add slots to sizers, it may be possible that you don't see such new slots: this happens because the size of the window that contains the sizer is too small, and so new slots are hidden. The solution is to resize the window, so that its layout is recalculated and the new slots are shown.
   
• XRC code generation has some differences wrt Python or C++; apart from those already mentioned in section 8, the most important ones are:
  • Some widgets are not supported at all (e.g. status bar and grid): for them no code will be generated, but instead the XRC output file will contain a comment like this:

    <!-- code generator for wxStatusBar objects not available -->
        

  • Output files are always overwritten, so if you manually edit the XRC file, all the changes you made will be lost when you re-generate it.
  
   
• Starting from version 0.2, there's a special component called CustomWidget (). This is different from the others because it can be used to include in a wxg file any widget, even if it is not directly supported by wxGlade. The key feature for this is the Arguments property, which has two different meanings: for Python or C++ output, it lets you define the constructor parameters for the object. In this case it has two special parameters, $parent and $id, which as you can guess by their names are placeholders for the actual parent and id of the object. For XRC output, instead, it lets you specify additional properties of the object. In this case each entry should be in the form

  name: value

  (invalid entries will be silently ignored): for each of these lines, the output will contain a

  <name>value</name>

  property of the XRC object.
   
• Starting from version 0.2, there's a script called xrc2wxg.py shipped with wxGlade. You can use this script to convert an XRC file to a wxGlade resource, so that you can edit it with wxGlade itself. Its usage is straightforward:

  python xrc2wxg.py xrc_file.xrc wxg_file.wxg

  (if wxg_file.wxg is omitted, it defaults to xrc_file.wxg), but there are some limitations you should be aware of:
  • First of all, it can handle correctly only "wxGlade-friendly" XRC files. This basically means that all windows but the toplevel ones must be inside a sizer (but there are other cases).
  • All the widgets unknown to wxGlade will be replaced by the special CustomWidget component.
  • Finally, xrc2wxg is very experimental, and so it probably contains many bugs. If you find one of them, please report it (this is valid for wxGlade in general, BTW).
     
• You can invoke code generation also from the command line, without starting the GUI. For the details, type

  python wxglade.py -h

  at your shell's prompt.

I hope the contents are clear (and my English not too ridicule), anyway for questions, comments, critics you can reach me by e-mail at [agriggio <at> users <dot> sf <dot> net].

Screenshots.

Custom Search

If you liked this article, subscribe to the feed by clicking the image below to keep informed about new contents of the blog:

KMix is an application to allow you to change the volume of your sound card.

KMix is an application to allow you to change the volume of your sound card. Though small, it is full-featured, and it supports several platforms and sound drivers.

By default, clicking the KMix icon in the system tray shows the master controller where you can increase or decrease the overall volume. To switch off the sound, click the green LED, which darkens when it is muted.

Toggle this option by clicking the LED again. To fine-tune your sound settings for several channels, right-click the KMix icon and select Show Mixer Window. In the main window, you can configure Output, Input, and Switches. Each of the devices featured there has its own context menu that is opened by right-clicking the device icon. You can mute or hide each one of them separately. For further information about KMix, refer to the online help.

Features.

    Support for ALSA and OSS sound systems
    Plasma Desktop integrated on-screen-display for volume changes


These days the GUI mixers KMix and GNOME Sound Preferences display PulseAudio devices and streams rather than ALSA mixer channels. For example, prior to its integration with PulseAudio, KMix typically displayed a mixer window that looked like the one below.

KMix with ALSA channels

whereas, today, a KMix window typically looks like the following:

KMix with PulseAudio channels

KMix 3.8 in KDE 4.6.1 does not provide separate speaker and headphone channels. You can alter the headphone and speaker volume by using PulseAudio Volume Control instead (see the picture below), but people are not as familiar with the PulseAudio GUI, and it is yet another step to perform.

PulseAudio Volume Control showing selection of Headphones channel

If you are like me, you probably end up using KMix (or GNOME Sound Preferences) but also launch ALSA Mixer in a Konsole/Terminal for fine-grained control of the underlying ALSA channels:

ALSA Mixer running in Konsole

This is more hassle, because you launch Konsole/Terminal and you enter the command alsamixer and press F6 (alternatively, use the command alsamixer -c 0 if your sound card is Card 0). The PulseAudio channels are displayed by default if you don’t specify your sound card when you launch ALSA Mixer.
It would be handy to have an icon on the Panel or on the Desktop that you could use to launch ALSA Mixer. Well, you can. In fact, as there is also a GUI version of ALSA Mixer (albeit with a few less features than its console equivalent) you can use that instead if you prefer. Below I explain a few of the possible ways you can display ALSA Mixer easily from within a desktop environment.

Change KMix from a PulseAudio mixer to an ALSA mixer.

By default KMix displays PulseAudio channels instead of ALSA channels. However, if you want to display the ALSA channels instead (as shown in the first picture above), quit KMix and enter the following command in a Konsole window or in KRunner:

export KMIX_PULSEAUDIO_DISABLE=1 && kmix

If you want to make this permanent then add KMIX_PULSEAUDIO_DISABLE=1 to the file /etc/conf.d/alsasound

Personally, though, I prefer not to do this as I want to control the PulseAudio channels via the KMix mixer. Try running two or more audio/video apps simultaneously and you’ll see what I mean – it’s useful! For example, I can control the volume of various applications separately (handy when you want to check something or are using Skype), as illustrated by the picture below:

KMix showing PulseAudio playback streams tab

and I run ALSA Mixer separately to tweak the underlying ALSA channels. Using Yakuake (or Guake in GNOME) is quite a good way to run ALSA Mixer in a console: it is quick and easy to pop-up a window to launch ALSA Mixer, and ALSA Mixer is displayed in colour at nearly the width of the desktop.

Launch ALSA Mixer GUI from an icon on the Panel.

First, use your package manager to install the package alsamixergui. It’s a GUI equivalent of the console ALSA Mixer, but with a few less options.

Once you install it, you should find ALSA Mixer GUI in your desktop environment menu (e.g. Kickoff > Applications > Multimedia > ALSA Mixer GUI). By default this will show the PulseAudio channels, so use the menu editor (e.g. right-click on Kickoff and select Menu Editor) to change the command to the following if your sound card is Card 0:

alsamixergui -c 0

Once you have done this, save the new menu entry, log out and log in again, and when you launch ALSA Mixer GUI from the menu a window similar to the following will pop-up:

ALSA Mixer GUI

To put an icon on the Panel in order to make it even easier to launch ALSA Mixer GUI, just drag the icon from the menu to the Panel and it will be copied to the Panel. Simple as that.

Launch ALSA Mixer in a Konsole docked in the System Tray
You can do this using KDocker, which works in KDE, GNOME, Xfce and other desktop environments.
For KDE, create the following Desktop Configuration File Konsole-alsamixer.desktop (or whatever name you want) and put it in the directory ~/.kde4/Autostart/
[Desktop Entry]
Comment[en_GB]=Console (docked) running ALSA Mixer
Comment=Console (docked) running ALSA Mixer
Exec=kdocker konsole -e alsamixer -c 0
GenericName[en_GB]=Dock Konsole running ALSA Mixer in the System Tray
GenericName=Dock Konsole running ALSA Mixer in the System Tray
Icon=kmix
MimeType=
Name[en_GB]=Konsole (Docked)
Name=Konsole (Docked)
Path=
StartupNotify=true
Terminal=false
TerminalOptions=
Type=Application
X-DBUS-ServiceName=
X-DBUS-StartupType=
X-KDE-SubstituteUID=false
X-KDE-Username=

KDE System Tray showing Konsole docked using KDocker

Clicking on the docked Konsole icon in the System Tray will pop-up a Konsole window with the familiar ALSA Mixer running in it, as shown in the fourth picture above. Clicking on the icon again will minimise the Konsole to the System Tray.

Launch ALSA Mixer in a Konsole from an icon on the Desktop
For KDE, create the following Desktop Configuration File Konsole-alsamixer.desktop (or whatever name you want) and put it in the directory ~/Desktop/
[Desktop Entry]
Comment[en_GB]=Console running ALSA Mixer
Comment=Console running ALSA Mixer
Exec=konsole -e alsamixer -c 0
GenericName[en_GB]=Konsole running ALSA Mixer
GenericName=Konsole running ALSA Mixer
Icon=kmix
MimeType=
Name[en_GB]=Konsole
Name=Konsole
Path=
StartupNotify=true
Terminal=false
TerminalOptions=
Type=Application
X-DBUS-ServiceName=
X-DBUS-StartupType=
X-KDE-SubstituteUID=false
X-KDE-Username=
You can change the icon displayed on the Desktop either by right-clicking on the icon on the Desktop and selecting Properties or by editing the file directly. For example, I specified Icon=/usr/share/icons/mono/scalable/apps/kmix.svgz which looks rather retro and I think suits the unsophisticated looks of ALSA Mixer.

Custom Search

If you liked this article, subscribe to the feed by clicking the image below to keep informed about new contents of the blog:

Squeak is a highly portable, open-source Smalltalk with powerful multimedia facilities

The Squeak programming language is a Smalltalk implementation. It is object-oriented, class-based and reflective.

It was derived directly from Smalltalk-80 by a group at Apple Computer that included some of the original Smalltalk-80 developers.

Its development was continued by the same group at Walt Disney Imagineering, where it was intended for use in internal Disney projects.

Squeak is available for many platforms, and programs produced on one platform run bit-identical on all other platforms.

The Squeak system includes code for generating a new version of the virtual machine (VM) on which it runs. It also includes a VM simulator written in itself (Squeak).

For this reason, it is easily ported.

Dan Ingalls, an important contributor to the Squeak project, wrote the paper and constructed the architecture for five generations of the Smalltalk language upon which Squeak is built.

Squeak incorporates many of the elements Alan Kay proposed in the Dynabook concept, which he formulated in the 1960s. Kay is an important contributor to the Squeak project.

Squeak includes a number of user interface frameworks:

An implementation of Morphic, Self's graphical direct manipulation interface framework. This is Squeak's main interface.

Tile-based, limited visual programming scripting in Etoys, based on Morphic.

A new, experimental interface called Tweak. In 2001, it became clear that the Etoy architecture in Squeak had reached its limits in what the Morphic interface infrastructure could do. Hewlett-Packard researcher Andreas Raab proposed defining a "script process" and providing a default scheduling mechanism that avoids several more general problems.

The result was a new user interface, proposed to replace the Squeak Morphic user interface in the future. Tweak added mechanisms of islands, asynchronous messaging, players and costumes, language extensions, projects, and tile scripting.

Its underlying object system is class-based, but to users, during programming (scripting), it acts like it is prototype-based. Tweak objects are created and run in Tweak project windows.

In Squeak versions 3.8 and earlier, the MVC interface. It is derived from the original Smalltalk-80 user interface framework which first introduced and popularized the model-view-controller architectural pattern (so named after the three core classes of the framework). Thus, the term "MVC" in the context of Squeak refers to both one of the available user interface frameworks and the pattern the framework follows. MVC was provided for programmers who wished to use this older type of interface.

Many Squeak contributors collaborate on Open Cobalt, a free and open source virtual world browser and construction toolkit application which is built on Squeak.

Squeak is also used in the es operating system and for implementing the Scratch programming language for beginning programmers. In May 2011 the OpenQwaq virtual conferencing and collaboration system based on Squeak, an open source release of Teleplace, was announced on the Teleplace blog.

Features.

The list of features in Squeak is astonishing. What would, in other environments, be third party extensions downloadable elsewhere comes fully integrated in the standard Squeak release. Click on the links below to take a short tour of a small part of SqueakVille...

• Development
• Education
• Fun and Games
• Internet
• MultiMedia
• Research
• The Squeak VM

Smalltalk, the language, is:

• Dynamically Typed
• Strongly Typed
• Garbage Collected
• Interpreted
• Purely Object-Oriented
• Open Source
• Reflective
• Extensible
• Cross-platform
• Cross-OS
• Cross-hardware

Some features of Squeak

• Squeak's virtual machine is developed using Squeak itself. It is possible to execute and debug Squeak inside Squeak
• Squeak can be used for Web Application Development.
• See the Croquet project and Balloon for examples of Interactive 3D in Squeak
• Squeak has superb multi-media potential
• Squeak is internationalised! It supports Unicode and Localization for multi-lingual applications.
• Squeak is a persistent environment - when you save your image, every thing right down to the position of windows and text is saved.
• Squeak itself is an IDE. You can code, run and debug in the same environment.
• Squeak uses incremental compiling - once you've saved your code, it's ready to run

 Download.

Updates:

Squeak 4.2 Released

Squeak 4.2 has been released after nine months in development. 4.2 is cleaner and faster than 4.1, with a significant number of fixes and enhancements to the class-library, such as an API for accessing the operating system stdio. There were low-level core improvements too, such as the new microsecond-precision internal clock and legacy MVC support. IDE productivity is higher with the text-editor enhancements, and a new gesture for efficiently resizing and moving windows. Squeak 4.2 is compatible with the next-generation Cog VM.

License

Squeak 4.0 may be downloaded at no cost, including source code, as a prebuilt virtual machine image licensed under the MIT License, with the exception of some of the original Apple code, which is governed by the Apache License.

Originally, Apple actually released Squeak under a license called the "Squeak License." While source code was available and modification permitted, the Squeak License contained an indemnity clause that prevented it from qualifying as true Free and Open Source Software.

In 2006, Apple relicensed Squeak twice. First, in May, Apple used its own Apple Public Source License, which satisfies the Free Software Foundation's concept of a Free Software License [6] and has attained official approval from the Open Source Initiative[7] as an Open Source License. The Apple Public Source License, as it turns out, fails to pass the third standard that Free and Open Source Software licenses are held to: the Debian Free Software Guidelines promulgated by the Debian project, an influential volunteer-run GNU/Linux distribution. To enable inclusion of Etoys in the One Laptop Per Child project, a second relicensing was undertaken using the Apache License. At this point, an effort was also made to address the issue of code contributed by members of the Squeak community, which it was not in Apple's power to unilaterally relicense.

For each contribution made under the Squeak License since 1996, a relicensing statement was obtained authorizing distribution under the MIT license, and finally in March 2010, the end result was released as Squeak 4.0, now under combined MIT and Apache licenses.

Projects.

Below is a list of the most popular projects in Squeak. There is also a larger list available on SqueakSource.

Development.

• Monticello is a packaging system for Squeak (similar to CVS and Store for VisualWorks)
• SqueakMap is a world-wide catalog of packages developed in Squeak
• SqueakSource is the Squeak SourceForge that supports distributed development
  Differences between the above explained in this posting
• SUnit Tests are Unit Testing controls built-in to the environment.
• Refactoring Browser is a powerful Smalltalk Browser which allows the programmer to perform various automated refactorings on Smalltalk source code such as renaming variables and methods
• Magma is an implementation of an OODB (object oriented database) in Smalltalk

Education.

• Squeakland is the main access point for Squeak and education
• Etoy is a powerful script-based environment to learn sciences and maths
• Scratch is a new programmable toolkit that enables kids to create their own games, animated stories, and interactive art -- and share their creations with one another over the Net. Scratch builds on the tradition of Logo and LEGO/Logo, but takes advantage of new computational ideas to make it easier to get started with programming (lowering the floor) and extend the range of what kids can create and learn (raising the ceiling).
• ComiKit is a toolkit for children that uses a visual programming language based on comic strips. With ComiKit you can create interactive games and stories featuring animated characters. ComiKit is a result of research on visual programming at Linköping University.

Web Application Development.

• Seaside is a framework for developing sophisticated dynamic web applications by using Continuations and a URL code to preserve application state on the code stack, even across different browsers, dramatically easing the complexity of web application development.
• AIDA/Web is web application framework and server for complex web applications with REST-like Urls and MVC separation of domain model from presentation and with integrated user/security management.
• SmallWiki2 is a wiki based on Seaside
• ShoreComponents is a set of useful components for Seaside

Innovative New Media and New Interfaces.

• Croquet is a 3D peer-to-peer authoring environment for simultaneous team content development of interconnected simulations, models, and simulated environments
• Sophie is a digital media assembly tool to combine images, text, video, and audio into a single multimedia document such as slideshows, presentations and annotated videos.
• Tweak is a media authoring environment for children of all ages. It's Morphic redone from scratch, to add flexibility, more powerful abstractions, and clarity of code.
• Morphic is a direct-manipulation User Interface (UI) construction kit based on display trees. It works with graphical objects called Morphs. It replaces the original Model View Controller graphics toolkit of Smalltalk-80.
• wxSqueak is a Squeak interface to the wxWidgets GUI library, meaning that a platform's native GUI widgets are used.

More projects.

• Quoth is a dynamic, interactive fiction system with an eye toward musical livecoding
• ODECo is an easy tool kit for making 2-D & 3-D dynamics simulation based on ODE http://www.ode.org, a physics motion simulator (download the SqueakFest '04 image for windows and linux for the 2D simulation)
• NetMorph is a visual mobile agent system. In the environment, network-enabled morphs (art, media, and/or widgets) can move freely across the World (desktops of various networked computers) to lead to new kinds of collaboration.
• Weather On Display is in many ways the finest weather instrument available today. From sensors at your site, local weather information is processed and displayed in an intuitive and accurate manner. If you watch the weather, you will love Weather On Display.
• Open Agument. Created in the 1960's by Dr. Douglas Engelbart and his imaginative team at Stanford Research Labs (SRI), Augment is one of the most groundbreaking and important historical artifacts of the software industry. Many of today's desktop and network computing innovations can be traced back to the original Augment system.

Bleeding Edge Projects.

• Traits is a project to add Aspect Oriented attributes (or Mix-ins) to Smalltalk
• BabyUML is a laboratory to explore new programming disciplines that simplify and twist UML and other constructs to demonstrate how they help bridge the gap between programmer and the objects running in the computer focusing on the run time objects; the classes that specify them are moved to the background
• Spoon is a project to create applications from a tiny, minimal core that dynamically grows its class library as the classes are used
• Exupery is a project to improve Bytecode compilation and execution
• Package Universes are an approach to supporting no-hassle installs via a package loader.

Screenshots.

Custom Search

If you liked this article, subscribe to the feed by clicking the image below to keep informed about new contents of the blog: