2012-09-22

hello to founder of diotavelli.net's PyQt wiki

7.11: web.co.cyb/dev/who does diotavelli.net?:
. the supporter of the pyqt wiki
also has a page on gpgpu .
. other details of his coding career:
studying Computational Linguistics
    2003‒2006: Tübingen (BA)
    2007‒2009: Saarbrücken (M.Sc.)
. here's his papers .

at Google ZRH:
"( Computational Linguistics means
the theoretical foundations
and wonderful world of algorithms .
eg, writing small toolkits for finite state automata. )
what does his toolkit do?
"(    Determinization of NFSAs to DFSAs
    Creation of DFAs from simple regular expressions
    Application of FSTs
    dot graph output for *FSAs
-- if you like PyParsing
and generator-expression-prone Python code,
you might want to have look at
the TinyFST code.)
salsa project page @ coli.uni-saarland.de:
"( One of the most urgent problems in language technology
is the lexical semantics bottleneck,
the unavailability of domain-independent lexica
with rich semantic information on lexical items.
Such lexica could greatly improve
the quality of current applications.
At the same time, providing
large-scale lexical semantic information
is an enormous challenge,
due to the size of the vocabulary
and the inherent vagueness of lexical meaning.
Our aims are:
    Providing a large lexical semantic lexicon
    providing semantic and syntactic properties for
    German lexical items,
    to serve as a rich static database.
    Developing techniques for the wide-coverage statistics-based
    semantic annotation of texts.
    Investigating the use of contiguous frame annotations
    for dynamic semantic analysis
    in practical natural language processing applications).
The TreeAligner Project
"( The TreeAligner is a tool for annotating and browsing
correspondences between elements of syntactical trees.
It can be used for creating paralell treebanks.
It also includes a powerful search function.)
. his latest blog entry for dev is
2009/py for gnome
-- I don't see any interest in pyqt at all
except for knowing about his wiki .

Scrollable Widgets with PyGTK 2009:
. the code for that project is online at
www.cl.uzh.ch/kitt ... gtktreeview.py#l199 .
-- © 2007-2009 The TreeAligner Team, at ifi.uzh.ch,
GNU GPLv2 . import gobject, gtk, cairo ...

iOS app restriction motivations

7.22: todo.cyb/dev.iOS/
menu-driven prog'lang learning:

. I thought of an addx app for iOS:
let users try programming by menu .
. even if iOS users can't run the programs
that they create by menu,
it's a way to learn to program
by exploring menu's;
but in that case, it would need to be
for a way of learning a popular lang, not adda;
adda is interesting only if it's
a way to do something popular;
eg, you could make your iOS do things
by running the code you just built .
. this could be done via the use of javascript
by somehow sending it to the browser ?
[9.9:
. I should be keeping in mind that for $99/yr,
such an app should be designed to make money;
if I just want to be helpful,
I can do that for free with a web app .]

7.29: news.cyb/dev.iOS/
co.dev.mac#buck has book for dev.iOS?:

. it's one thing to say that
every program has to be inspected,
but why does every user
have to be inspected?!
ie, why can't the user write scripts ?
a user should be able to automate
anything a programmer is allowed to do .
. but it's a slippery slope;
if you let users do scripting
then they are trading scripts,
then they are failing to notice
what "they" are doing .
. can javascript come close to doing
everything a user can do ?
. another problem is user spoofing user:
many services like google
can't be used by automation because
then a human wouldn't be
influenced by the ad's,
so there would be no use serving ad's,
and no way to fund the product ...
(not sure that's a problem on the iOS;
Android users get served a lot of ads).

Pyglet for multi-media Python

7.16: news.cyb/dev.py/pyglet for cross-platform gui:
. during rapd's 2009 python promo,
pyglet was listed along with scipy
as some examples of how python leads ruby
in everything but web programming?
that makes pyglet interesting!
(a cross-platform, BSD-licensed
windowing and multimedia Python library ):
. provides an oop interface for developing
games and other visually-rich applications
for Windows, Mac OS X and Linux.
The major 1.2alpha1 release
brings pyglet to Python 3.
Pyglet now also runs on 64-bit
Linux, Windows and OS X.
The OS X layer switched to using Cocoa.
There's also a load of bug fixes,
updates to the OpenGL wrappers
and other minor new improvements.

Some of the features of pyglet are:
# No external dependencies
or installation requirements.
# For most application and game requirements,
# pyglet needs nothing else besides Python,
# simplifying distribution and installation.
# Takes advantage of multiple windows
and multi-monitor desktops.
# Load images, sound, music and video
# in almost any format:
# pyglet can optionally use AVbin to playback
audio formats such as MP3, OGG/Vorbis and WMA,
and video formats such as
DivX, MPEG-2, H.264, WMV and Xvid.
compared to pygame 2010:
. if you want it done quickly, use pygame.
but in a serious project, go for Pyglet,
which is nicely designed and implemented.
daniweb 2009:
Pyglet is not a full GUI toolkit,
[ it's a kit for making gui kits ]
but has its strength in audio and video presentations.
using GL and FFmpeg .
sparkyb 2008`not a traditional gui kit:
a graphics/game library like Pygame or Pyglet
is not the right kind of thing for a [ desktop app ].
You're better off with a GUI toolkit that already has
things like text fields, buttons, lists, task tray icons, etc
than trying to build your own with a graphics library.
(the question for a desktop app then
is pyqt vs wxPython).
wikibooks python gui kits 2011:
(no mention of pyglet)
7.17: ironically,
there's a book by "(wikibooks contributers)
that recognizes Pyglet on Page 144:
2D Game Programming
... Pyglet is avaible[sic] under a BSD-Style license ...
[ also listed under 2D Game are Pygame (wraps SDL)
and Rabbyt (a fast Sprite library) ]
. indeed, here it is at wikibooks.org,
under 2D Game Programming:
    # Pyglet is a cross-platform windowing and multimedia library for Python
    with no external dependencies or installation requirements.
    # Pyglet provides an object-oriented programming interface
    for developing games and other visually-rich
    applications for Windows, Mac OS X and Linux.
    # Pyglet allows programs to open multiple windows on multiple screens,
    draw in those windows with OpenGL,
    and play back audio and video in most formats.
    # Unlike similar libraries available,
    pyglet has no external dependencies (such as SDL)
    and is written entirely in Python.
    Pyglet is available under a BSD-Style license.
    also mentioned are Pygame, Phil's Pygame Utilities (PGU)
    Kivy, and Rabbyt .
--
. of these entries, only Pygame is
noteworthy enough for wikipedia;
other links go to their respective sites instead .

. even more weird is this:
Pyglet [Paperback] by Ronald Cohn Jesse Russell
Publisher: VSD (January 1, 2012)
-- described as
    "( High Quality Content by WIKIPEDIA articles!
    Pyglet is an OpenGL-based software library
    used in developing games
    and other visually rich applications
    using the object-oriented language Python.
    This book was created using
    print-on-demand technology.
) but at wikipedia,
it's been deleted as not noteworthy !
. and as you might expect, amazon says
"(Currently unavailable.
We don't know when or if this item will be back in stock.)
. the same author did a wikipedia reprint of
wiki's Crystal_Meth_Anonymous page;
and, that is also listed as unavailable,
but wiki still has that article (one very short page).

wikipedia (Pyglet deleted):
. non-notable, yet one very notable thing about it,
advocates were pointing out,
is that it's used as the base for Cocos2d:
a framework for building 2D games, demos,
and other graphical/interactive applications.
main features of cocos2d:
# Pyglet Based: No external dependencies
# OpenGL Based: Hardware Acceleration
. but wiki says Cocos2d is notable essentially
for being no longer dependent on Pyglet;
rather, they've been very busy with
porting to java, c++, and obj'c .
. and, as a result of such porting
it was featured in the book:
More IPhone Cool Projects
(see section "Cocos2D for iPhone and iPad;
                    It Is Easier Than You Think")

-- easy iOS programming is very noteworthy,
because, Python isn't even allowed on iOS!

9.6: web: Pyglet's newsgroup:
On Saturday, 28 July 2012 12:30:04 UTC+2, Scott Porter wrote:
> I've just upgraded to OSX 10.8
  and installed Pyglet 1.2alpha. 
> Pyglet is now unable to create any windows. 
Adam Griffiths Sep 5, 11:55 pm
I've been using Python 2.7 with PyObjc 2.2
with Pyglet from head (or 1.2 alpha).
It's the only combination that's ever worked for me.
I'm able to run Pyglet on 10.7 and 10.8 without any problems.
I wrote about this here:
I installed pythonbrew, virtualenv
into the system python.
Then install 2.7 with pythonbrew
and install Pyglet from the repository.
If I remember correctly,
the problem people are having with 10.8
is the system python uses certain libs.
Avoid using it and you shouldn't have any problems.
02/21 installing-pyglet-in-mac-os-x/
. Pyglet 1.1 uses the Carbon framework,
but this is not compatible with 64-bit Python installs.
The Pyglet 1.2 branch has been modified to use Quartz, ...
We must instead install Pyglet from the Mercurial repository.
The Quartz bindings require the use of PyObjc ...
Travis Griggs Aug 28, 4:23 pm:
1) Download mercurial and install it.
2) Clone the pyglet repository by opening up a terminal and running:
    hg clone https://pyglet.googlecode.com/hg/ pyglet
3) Go into the pyglet directory and install it
(type in your password when  prompted and press enter):
    cd pyglet && sudo python setup.py install   
Tristam MacDonald's pyglet blogging .
. he wrote this pyglet openware:
simplui -- Lightweight GUI toolkit for pyglet.
simplui provides a lightweight and flexible GUI toolkit
for Python/OpenGL applications using pyglet.
Primarily intended as an aid in debugging and development,
simplui is generally overkill for in-game GUIs.
other openwares by same author:
pyeuclid and cocoa-python .

=== other pyglet-related projects
on code.google.com ===

== pyglet shouldn't depend on PyObjC ==
cocoa-python -- Port of Objective-C runtime
to Python using ctypes
"( Port of the Objective-C runtime to Python using ctypes
with the goal of being able to
use the Cocoa API on Mac OS X without PyObjC.
... so that pyglet could run without depending on PyObjC.)
== pyglet should interface xcb not just xlib ==
samurai-x -- a pure python window manager for X
"( samurai-x is written entirely in python using ctypes.
The xlib module is from http://pyglet.org
but project was halted to write an
xcb-based window manager.
. XCB (X protocol C-language Binding)
is a C language binding for the X Window System.
It is implemented as free software
and aims to replace Xlib.
Xlib/XCB provides application binary interface
compatibility with both Xlib and XCB,
providing an incremental porting path.
Xlib/XCB uses the protocol layer of Xlib,
but replaces the Xlib transport layer with XCB,
and provides access to the underlying XCB connection
for direct use of XCB.)
== Pyglet wasn't flexible and pyopengl too slow ==
pocketwatch -- An opengl graphics library for python.
"( Pocket watch is an OpenGL graphics library for python,
write simple 3d programs.
why!? what about pyglet?
Pyglet is awesome, and pocketwatch uses pyglet
to do some specific things
like window management, rendering text,
and opening images.
Pyglet now supports some features that
may have been useful to solving the problems
I had when I started writing pocketwatch.
But even then,
said features didn't seem flexible enough
to do what I wanted.
Maybe this is different now, maybe not. )
py-open-gl ?
"( using ctypes to do lots of opengl calls
is actually very SLOW.
So instead, I took all of the code that I could,
and wrote a simple C++ library
to do all the nitty gritty stuff,
and wrote a python state-sorter which could
render all of the objects with a single ctypes call.
. uses Python Imaging Library (PIL)
. PIL adds image processing capabilities
to your Python interpreter.
This library supports many file formats,
and provides powerful image processing
and graphics capabilities.)
== libraries that help you use Pyglet ==
pyglons -- rapid application framework for pyglet
"( No more boilerplate coding!
pyglons takes the ideas from Pylons
( a lightweight web framework emphasizing
flexibility and rapid development )
and uses them to create a framework for Pyglet
( a cross-platform windowing and
multimedia library for Python) .... )
pyglons, the module:
"( a module containing an application base class,
a state class and some predefined states
that you may or may not require depending on your needs.)
pyglons, the templates:
"( templates for the paster command
that creates your application directory and initial layout.
The default templates create a small working application
with splash screen, menu, help and
very basic application state
ready for you to add your code.
The templates also create all the required files
to use your application with distutils/setuptools.
The default pyglons app depends on pyglet and pyglons.)
layer
"( Layer is a set of somewhat disjoint modules
on top of pyglet, YAML, and other Python libraries
designed to smooth over strangeness
and allow for rapid iteration in game design and development.)
pgedraw -- Simple library that
make[s] it easy to draw in 2d with pyglet
"( the goal of this very simple library
is to cover up the lack of a decent
drawing system in pyglet.
. pgedraw helps to draw 2d
geometrical shapes with pyglet.
A simple way to clear the screen
and to enable alpha channel is provided, too.
Drawing are made using pyglet's OpenGl api,
but knowledge of OpenGl is not required to use pgedraw.
Pgedraw offers also a collision detection system
that can be used to check if the user is
clicking inside a drawn shape.)
python-pyknic -- A boilerplate library for
the rapid creation of 2D games in Python.
pyglet-shaders
-- Feed GLSL shaders into OpenGL from Python
(uses pyglet bindings)
los-cocos -- cocos2d: A framework for building 2D games
"( cocos2d is a framework for building 2D games, demos,
and other graphical/interactive applications.
It is built over pyglet.
. helps you structure a "scene based application".
Cocos simplifies the game development in these areas:
Flow control: Manage the flow control
between different scenes in an easy way .
Sprites: Fast and easy sprites .
Actions: Just tell sprites what you want them to do.
Composable actions like move, rotate, scale, etc .
Effects: Effects like waves, twirl, lens and much more .
Tiled Maps:
Support for rectangular and hexagonal tiled maps .
Collision: Basic pure python support for collisions .
Transitions: Move from scene to scene with style .
Menus: Built in classes to create menus .
Text Rendering:
Label and HTMLLabel with action support .
Built-in Python Interpreter: For debugging purposes .
Access to OpenGL functionality .)
== libraries that use Pyglet ==
bruce-tpt -- Bruce, the Presentation Tool
"( It uses pyglet to display via OpenGL
and handle multi-head
(the most common presentation setup)
so you can have the presentation displayed on a projector
while your laptop displays the original presentation source .)
pyglet-twisted -- Twisted reactor for Pyglet
"( . develops a Twisted reactor for Pyglet.
The aim is to enable Twisted's networking capabilities
to be fully integrated within the Pyglet event loop,
introduced in version 1.1.)
skyseam -- Utilities for 2.5D graphics in python
"( . a utility to orient a spherical projection
to suit a list of camera views.
pyglet based ui for visualization and testing.)
pyevocomm -- a simple open Framework for Accesibility
"( Designed with the MVC pattern,
adds to the view beyond,
the voice properties suitable for
people with low vision .)
py-lepton -- High-performance, pluggable particle engine
and API for Python
"( make complex and beautiful particle effects;
Two pluggable OpenGL renderers,
and two pygame renderers
Modular architecture:
easily configure and customize the engine .)
roller-ball -- A Python/OpenGL Game
"( PyODE engine with OpenGL calls
using Pyglet framework .)
flashy-screen
"( Flashes / strobes your screen with random solid colors.
Intended to try and fix stuck pixels on LCD TVs and monitors.
All you need to run this is python and pyglet ).
pynewt -- Pure python rigid body dynamics library
"( Uses  pyglet for rendering,
needs pyeuclid for all vector/quaternion maths.)
news.cyb/dev.py/ui frameworks:
PyGame  -- graphics and sound by SDL
pyglet -- minimalistic;
tends to be basis of game engines .

Panda3D -- game engine
PyOpenGL -- graphics library
OGRE -- scene-oriented, flexible 3D
   rendering engine (as opposed to a game engine)
TurboGears, Django -- web apps
urwid -- console user interface library for Python.
PyQT -- cross-platform GUI toolkit
wxPython -- a widget toolkit and tools library for gui's;
. for more see list of game engines (python):
blender -- listed under ray tracers too .
cocos2d
Ignifuga Game Engine
Panda3D
-- for lesser game engines and media kits
see wikibooks .

wikipedia`game engine:
. a system designed for the creation and
development of video games.
The leading game engines provide a software framework
that developers use to create games for
video game consoles and personal computers.
The core functionality typically provided by a game engine
includes a rendering engine (“renderer”) for 2D or 3D graphics,
a physics engine or collision detection (and collision response),
sound, scripting, animation, artificial intelligence,
networking, streaming, memory management, threading,
localization support, and a scene graph.
The process of game development is often economized,
in large part, by reusing/adapting the same game engine
to create different games,
or to make it easier to "port" games to multiple platforms.
Recent Trends
. As game engine technology matures and becomes more user-friendly,
the application of game engines has broadened in scope.
They are now being used for serious games:
visualization, training, medical, and military simulation applications.
To facilitate this accessibility,
new hardware platforms are now being targeted,
including mobile phones (e.g. Android phones, iPhone)
and web browsers (e.g. WebGL, Shockwave, Flash, Trinigy's WebVision,
Silverlight, Unity Web Player, O3D and pure dhtml).
Additionally, more game engines are being built upon
higher level languages such as Python (Panda3D).
As most 3D rich games are now mostly GPU-limited
(i.e. limited by the power of the graphics card),
the language's impact on speed becomes negligible,
while the productivity gains offered by these languages
work to the game engine developers' benefit .
Game Middleware
. In the broader sense of the term,
game engines themselves can be described as middleware.
In the context of video games, however,
the term "middleware" is often used to refer to
subsystems of functionality within a game engine.
Some game middleware does only one thing
but does it more convincingly or more efficiently
than general purpose middleware.
For example, SpeedTree renders the realistic vegetation
and, Fork Particle simulate real time Particle Systems .

python faqts, "style" surprises, testing sw

7.15: news.cyb/dev.py/help at faqts.com:
Python Knowledge Base
[defunct]: www.faqts.com has a lot of
example code using dictionaries.
http://www.faqts.com/knowledge-base/index.phtml/fid/541
http://www.faqts.com/knowledge_base/index.phtml/fid/199
. here is the archive of the defunct site:
(FAQTS : Computers : Programming : Languages : Python)
and both of the defunct url's work appended to that archive url
(http://web.archive.org/web/20010616225136/)
also, the example code was part of
a snippets library:
here is the help on operating on files;
eg,
# the directory of the currently executing program:
import sys, os
if __name__ == '__main__':
    _thisDir = sys.argv[0]
else:
    _thisDir = sys.modules[__name__].__file__
_thisDir = os.path.split(_thisDir)[0]
print _thisDir
7.21: news.cyb/dev.py/style guide has some pragma too:

. the python style guide is more than just formatting;
it has some pragmas and gotcha warnings too;
eg,  Programming Recommendations:
Code should be written in a way that does not disadvantage
other implementations of Python
(PyPy, Jython, IronPython, Cython, Psyco, and such).
For example,
do not rely on CPython's efficient implementation of
in-place string concatenation for
statements in the form a += b or a = a + b.
Those statements run more slowly in Jython.
In performance sensitive parts of the library,
the ''.join() form should be used instead.
This will ensure that concatenation occurs in
linear time across various implementations.

Comparisons to singletons like None
should always be done with is or is not,
never the equality operators.
Also,
beware of writing if x
when you really mean if x is not None
-- e.g. when testing whether a variable or
argument that defaults to None
was set to some other value.
The other value might have a type (such as a container)
that could be false in a boolean context!
7.14: bk.cyb/dev.py/lists:
. index starting at 0(zero) means an insert(i, obj)
is the same as putting an obj after the ith item .
. list + list2
= list`extend(list2)
= list`append(list2[:])
= list`insert(-1, list2) .
7.14: 9.6:
. notice how stack is related to list:
pop = un(right-most element)
pop = un push;
push = append .
. which is the opposite of append:
is pop removing the right-most ?
9.6: yes, list.pop() is un-append;
pop() takes the right-most .
. list.remove(elem) finds an item equal to the given elem;
contrast that to L.pop(i), removes the ith element .
-- remove() searches for the first instance
(throws ValueError if not present).

7.24: web,news:
. see the usage of __all__ (a list)
in the __init__.py for packages .
If __all__ is defined in __init__.py,
and you use "from my_package import *"
then only the modules/variables defined in __all__
will be loaded.

>>> import os
>>> os.getcwd()
'/home/user'
>>> os.chdir("/tmp/")
>>> os.getcwd()
'/tmp'

# Linux:
export PYTHONPATH=/path/to/my/library:$PYTHONPATH
# Windows:
set PYTHONPATH=%PYTHONPATH%;C:\My_python_lib
7.16: news.cyb/dev.py/testing/windmill:

mikeal 2009`intro to windmill:
. Windmill is a Selenium competitor
written entirely in Python & JavaScript
with test-writing support for both.
Windmill`intro:
. Windmill is a web testing tool
designed to let you painlessly automate
and debug your web application.
Originating at the Open Source Applications Foundation
Windmill was built to help QA
keep up with the rapid release cycles
of the Chandler Server Web UI (Cosmo) project.
As the Cosmo client is heavy in
JavaScript and AJAX functionality,
Windmill makes the communication
between the service and the client code
a priority.
Windmill Test Framework:
. Cross-browser test recorder
Record, edit, playback and interact with your tests
from one simple interface.
. Also check out the DOM Explorer, Assertion Explorer
and fully integrated Firebug-Lite.
Interact from a python shell with the
browser and the windmill service .
. install ipython and automatically get
an even more usable shell.
. more encouragement 2011:
"( Selenium 2 and Python
- ok so Windmill is my new favorite:
This looks interesting!:
http://readthedocs.org/docs/selenium-python/en/latest/
Update: Windmill is more fun now .)

exploring resources at diotavelli.net's PyQt Wiki

7.10: web.cyb/dev.pyqt/wiki:
. exploring the wiki at diotavelli.net.
news:
PyQt und PySide book has some example code:
-- the book is written in german:
PyQt und PySide: GUI- und Anwendungsentwicklung mit Python und Qt
Published: 2012 ISBN 978-3-941841-50-5
9.9:
. the .zip doesn't have a lot of example code,
but it's mostly English despite the text being German .
. the localization coverage looked interesting
but it used some strange resource files
that need explaining by the book .

great tutorials collection:

. tutorial for text editor (the code is here).

Test PyQt GUIs with QTest and unittest
by John McGehee on July 31, 2011
"( PyQt is the Python binding of the popular Qt
cross-platform UI and application framework.
For unit testing, PyQt clients are expected to use
the standard Python unittest module,
with just a little help from the PyQt QtTest module.
It is not immediately apparent how to blend these two frameworks
into a unified unit testing strategy.
In this article, I show you how to unit test a PyQt GUI dialog
using only modules included in PyQt and Python. )
Boudewijn Rempt & David Mertz @ ibm's comparison to tkinter.
. see his Charming Python series:
# dom (XML Python)
# concurrency
# Easy Web data collection with mechanize and Beautiful Soup
# ide's .

IPython has Powerful Python shells (terminal and Qt-based).
IPython 0.13: a major release (June 30, 2012)
"( This release, closed 1115 issues Github
and comes with major improvements to the
notebook and parallel computing APIs,
a new cell magic system,
unified interactive and parallel kernels ).
pyqt-based browser:
. installation instructions .
. code base at code.google.com .

other pyqt projects on g'code:
Lector
"( A graphical ocr solution for GNU/Linux
based on Python, Qt4 and tessaract OCR.
Lector can help you to scan your tons of paper
and create text document!
Lector lets you select areas on which you want to
do OCR (Optical Character Recognition).
Then you can run tesseract-ocr
simply clicking a button.
The resulting text can be proofread, formatted and edited
directly in Lector.
. see the OCRopus project,
for which Tesseract is one of the pluggable OCR engines;
OCRopus also provides layout analysis
and statistical language modeling.)
text editor:
"( Marave doesn't just have minimalism and simplicity,
it has that combined with beauty
and a palpable design ethic. Marave has soul.
Inspired by ommwriter and other similar projects,
aims to be a simple, clean text editor
that doesn't distract you from your writing.)
PyQt:creating GUIs with Python’s QT bindings

Boudewijn Rempt`GUI Programming
with Python: QT Edition
. this is a complete book online !
(somewhat obsolete though?).

7.16: news.cyb/dev.pyqt/zetcode book:
http://zetcode.com/tutorials/pyqt4/

7.17: news.cyb/dev.pyqt/wiki pages:
. Comparison_of_programming_languages;
python typing -- strong and safe but implicit
(by contrast Pascal -- explicit yet not completely safe)
. list of wiki's python books:
the people's pyqt book
-- they point to techbase.kde.org
"( to develop KDE applications using Python,
you need both PyQt and PyKDE.
. PyQt provides Python support for the Qt library
which KDE is built on.)
###
pyqt's relation to PyKDE:
"(. Riverbank Computing has a lot of good documentation
about how to use PyQt to create pure Qt applications.
If you are new to KDE / Python development,
then learning how to use PyQt is the best first step.
PyKDE builds on top of PyQt and adds
Python support for KDE's libraries and technologies.
PyKDE is distributed as part of the kdebindings module.
Stable releases can be downloaded from
the normal KDE download page,
although it is usually easier to
install pre-built packages from your
operating system distribution.
You can also obtain PyKDE from
KDE's subversion repository .
Or from KDE's git repository:
git clone git://anongit.kde.org/pykde4 ).

2012-09-21

editing trees

7.22: adde/gui/editing trees:
. how do we sync a tree with the editor's
textual representation of the tree?
as lines are added to the text,
the line numbers change
but the tree nodes never change
without needing to rebuild the text too.
. there are 3 objects at work here:
the tree, the array of strings,
and an intermediate that's like wordcode,
in that it's a string of ptrs to tree nodes
that are in turn printable as words or symbols .
. at each line we have a ptr to the tree
but a line serves several nodes .
9.5:
. the ptr heading each line of text
is pointing to the root of the subtree
that is on that line .
. if we change that line or insert lines below it,
those changes are happening to that subtree
indicated by the root node;
therefore, to reflect any changes to the text,
we need reparse only that subtree ... ?!
actually,
there are 2 cases of tree:
# prefix:
. in the presentation of a folder system,
all the child nodes are below the parent's .
. that is a very simple and easy case,
as was expected above .
# infix:
. in the presentation of math formulae,
and programming code, such as adda,
we have expressions like (a+b),
where if all these expression tree nodes
are on separate lines,
then you see the root in the middle of the page,
not at the top . a further complication is that
the same text line can be representing
2 different subtrees: eg,
line#1: a*
line#2: b + c*d;
. in that example, line#1 and #2
share pieces of subtree#(a*b),
and line#2 represents parts of 2 subtrees,
so if line#2 is edited,
then there are possibly 2 subtrees to reparse .

9.5: the real-time complication:
. the text editing has to be very responsive;
therefore, we can't map each word
to a subwindow corresponding to a subtree;
instead, we have to let the user edit plain text,
and then have some way of mapping
text changes back to tree changes .
. to minimize reparsing,
we have to map character positions to tree nodes,
and then track how character modifications
have effected our text-to-tree map .

9.5: typical conditions simplifying:
. one simplifier provided by typical conditions
is tree size limits:
the expression trees that are complicated,
are usually only a few lines long;
they are separated by sequence operators,
or list delimiters .
. in the case of programming,
the effect of one tree change
can effect the parsing of another;
because, a symbol's meaning can change
either by deleting or creating a declaration
which will have a scope beyond the current tree
extending throughout the enclosing declare block .
. if there's a decl'deletion,
then we have to notice what type was being declared;
because, sometimes the type is determining
how we parsed the expression trees
that were surrounding that symbol;
eg, a declaration tells us whether or not
a symbol can be used as an infix operator,
or whether it was an atom or a function .
. much of syntax is only allowed for
certain types of symbols and not for others;
so, can we find a symbol of the same name
in an enclosing scope, and of the same type,
or a type change that won't matter ?
we may have to reparse the entire enclosing scope .
. if there's a decl'creation,
we must ensure that this scope
doesn't already declare this symbol .
. if there's a decl'modification,
we must ensure that type change doesn't matter,
else we have to reparse the entire enclosing scope .

dialog fields that auto-copy pastebuffer

7.20: adde/gui/dialog fields that auto-copy pastebuffer:
. when a menu needs additional information,
it launches a dialog .
. often we get the needed info by cut&paste;
so, one shortcut for filling a dialog
is having it listen for the next
cut or copy {ctrl-c, ctrl-x}
then automatically copy the pastebuffer
into the current field,
and finally, transfer dialog focus
to the field where the paste just happened .
. when it does this automation
it also switches itself to the forefront
(but not on top of all other windows;
instead it's alongside the current window
resizing it if needed)
so you'll be reminded in case you forgot
that you were in the middle of a dialog .
document access during a dialog:
. the dialog was launched from a home document;
and we may need access to the home document
because that may be where we can
copy what needs to go into the dialog .
. but if the home document is modified,
that could change the dialog's selection;
and then the dialog is no longer valid,
because it was for a menu item
that may no longer apply to
what's left of the original selection .
. the user should still be able to modify
other parts of the home document
(parts not selected during the dialog).
so, adde must be able to detect
whether just the selection has changed;
eg, put a tag in the doc,
showing where the selection starts,
and the tag includes the size of selection,
along with the hash value .
(if the selection has been changed,
then the selection tag will be gone,
or the hash will be different).

7.20: adde/gui/dual help-run menu items:
. the [?]-icon beside each menu item
is there to show the doc's for an item
rather than launch the item .

building menus per selection's type

7.20: adde/gui/building menus per selection's type:

. when any content is selected,
the menu should reflect appropriate commands;
and, that will typically be depending on
the selection's datatype,
but there can be several:
. all code can be seen as a character string,
then there are generic types
and finally there could be specific types;
eg, select a list, and maybe there's some
type that is based on a list (its literals use
a constrained version of list syntax).
9.5: eg,
when you've imported type spreadsheet,
and have selected a list of lists,
then one of the available menu options
is a list of spreadsheet commands
that treat lists of lists
as if they were spreadsheet tables .

automated menuization:
[9.5: intro:
. menuization means the process of
converting a module's interface
into a human-usable menu that is
just as powerful as the module's API
(application programmer's interface).
]
. any module menuization can be automated
from reading a module's code,
so how to know when a module is a typedef,
and the definition includes value literals
that match words in the current selection?
any subtle cases? .
...
. one thing that helps adde identify types:
it tries to parse as much into adda as possible;
so if that parsing found any type info,
the code will already be tagged with type info,
and all operations related to that type
would be presented in the current menu .
9.5:
. one thing adde can do when the selection contains
english words that match imported type literals
is tag those words as being of that type
rather than english type (being of english type
means the exact meaning of the word
can be found in an english dictionary).
. given a selection, the menu can help you find
the meanings of each word,
according to every imported dictionary
including the value literals of typedefs .
. eg, if you selected green after importing trafficlight,
then one definition of that would be
trafficlight`image#3 .

7.22: automated menuization/handling non-terminals:
. part of auto-menu-ization needs to deal with
the params of control types:
eg, when the menu provides an if-then stmt,
it inserts a string with params like this:
if<truth> then <subprogram>;
then if you select <truth>
the menu needs to show all this:
[current truth vars...], [make new truth var];
[functions that output truth...];
[operations that inout truth ...], etc .
. say you replace <truth> with
<truth> = <truth>
then you repeat the process .
. it should use a context menu tip too:
the moment you select a <truth> text
the right menu is open,
and your mouse focus is in it .
-- that would be like writing only better .
9.5:
. while there are <VAR> texts in place,
the editor is in a different mode:
where the tab and other navigation keys
are hopping between <VAR>s,
and the enter.key is opening the menu .
. when the menu is closed,
then the focus is on the
newest left-most <VAR> .
. the up-arrow.key goes up the expression tree;
down goes to the left-most child node;
right-arrow.key, and tab.key move linearly right,
left-arrow.key moves linearly left to next <VAR> .
. the esc.key toggles between {text, <VAR>} modes .

7.23: automated menuization/handling non-terminals:
. we could do the same thing for
teaching natural language to foreigners,
helping them build expressions in a 2nd lang .

interactive adda sessions

7.19: adde/interactive adda sessions:
. rather than the usual terminal interaction,
there are 3 boxes (input, output, and hist)
. hist (short for history) is a text list of
what went into the input box recently .
. it's both a sequence of text lines,
so, you can edit it;
and it's also a sequence of statements,
so you can set your cursor on any statement
and do a {ctrl-r, menu/run}
to have the selected statement copied to input
where it then gets run .
[7.19: 9.5:
. the interaction file can be decomposed by
saving the current interaction sequence
as a subprogram named x:
it then saves it in a file named x`body,
like any other subrogram definition;
and, back at the hist file,
the sequence that had just been saved
is turned into a subprogram definition .]

. the hist window is also an outline editor,
so, for each subprogram definition,
the body of the subprogram can be collapsed
into the name of the subprogram .
. you can either see things as a tree,
or see just one node of the tree .

. each interactive symbol definition
is stored as a file in a folder named
interactive.adda; and when you're done,
you can save the session to folder x,
so then it copies interactive.adda to x.adda .
. if x already exists, you can either
merge hist with the selected
or have hist replace it .
9.5:
. merging is useful when your interactions are
developing pieces of a library;
replacements would useful for keeping track of
recent interactions,
eg, by naming sessions after days of the week,
you could always keep 7 days of session history .

vocabulary size conversion

7.11: adde/vocabulary size conversion:
. if you'd rather not learn a large collection of library calls
it should convert imported source code
by expanding each 5-dollar word
into a paragraph of 5-cent words .
. this could have the side-affect of running slower
because the 5-dollar words are
packing a lot of code into a c module .
. so it might be useful to implement it
only at the presentation layer;
ie, if you don't modify the expansion,
then it converts the expansion back to its 5-dollar word .
9.5:
. another way of putting that,
is that addx should be giving you a dual library
where everything is visible as adda code,
but it's mostly impl'd in c code,
unless you change the c's adda twin,
in which case it compiles that adda change into c,
and then, of course, into a binary .
. notice how Python does it differently:
it auto'compiles your scripting to Python bytecode;
but porting to C requires manual effort .
. the reason for this is that most Python code
makes extensive use of the Python virtual machine,
and there is efficient translation from Python to C;
rather, it takes human skill to sort out
where the hotspots are, and how to untangle them
for separation into a C file .
. adda, on the other hand,
encourages explicit typing;
and, if the user has done that,
then conversion to C should be easy and useful .
. adde should be tracking user's
adda file modifications,
and not bothering to C-translate it
until the user seems to be done tweaking it .

Microsoft's Open Specification Promise

12.7.17: news.adds/openware/
Microsoft's Open Specification Promise

Microsoft Open Specification Promise (or OSP),
is a promise by Microsoft, published in September 2006,
to not assert legal rights over certain Microsoft patents
on implementations of an included list of technologies.[1]

The OSP licensing covers any use and any implementations
of an appended list of covered specifications.
It is limited for implementations to the extent that
they conform to those specifications.
This allows for conformance to be partial
and does not require the conformance to be perfect.[2]

Compatibility with open source licensing
The OSP is effectively a patent sublicense to everyone
limited to use with certain formats and required technology
to implement OSP licensed formats.

Open source licenses, in general, deal with
licensing of copyrights of contributors to the software.
GPLv2 is an example of such copyright licensing.
GPLv2 does not grant you 3rd party (patent) rights.

The open source software (OSS) licensing deals with
copyrights on the source code created by the contributors.
Source code based on an OSP licenced format specification
has its own copyrights and is therefore
sublicensable by the contributors themselves.
The OSP is only about patent rights.
It grants additional rights to implementers and users
to the OSS licensing.

Because Microsoft through the OSP grants patent rights to anybody that
implements or uses technology required for OOXML
there is no need for sublicensing of patent rights through the GPL.
OSS users and implementers get the same rights automatically.

An OSS implementer that uses GPL software which
implements an OSP licensed format,
is granted certain copyrights on the software
through his GPL license,
which are granted by the prior software contributors;
and, is allowed to use Microsoft patents
for required format related technology through the OSP license.

Scope limitation
The Software Freedom Law Center, which provides services to
protect and advance free software and open source software,
has warned of problems with the Open Specification Promise
for use in free software / open source software projects.
In a published analysis of the promise it states that[7]
    "...it permits implementation under free software licenses
    so long as the resulting code isn't used freely."[8]
On March 12, 2008 the Software Freedom Law Center warned
over a possible inconsistency with GPL[8]
and in specific the limited scope of the OSP.
This applies specifically to the patent promise scope
being limited to conforming implementations of
covered specifications only.

Effectively when an implementer owns a patent
and builds that patent technology in GPL3 licensed code,
the implementer grants those first party rights patent rights
downline to all re-users of that code.[9]
If you use third party OSP protected patents in GPL3 code,
you cannot sublicense those,
and the OSP scope is limited to required (normative) parts
of the covered specification.
This means that when the code is reused,
the OSP only applies as long as the reuse of that code is
limited to implementing the covered specifications.
If the OSP was not limited in that way,
you could implement all patented technology
in a GPL3 code implementation
after which the code patented technology could be reused freely
for all other possible implementations.
The limitations of a one-sided patent promise
only applying to covered specifications
is also present in the IBM
Interoperability Specifications Pledge (ISP)
and Sun Microsystems' OpenDocument Patent Statement

This means, for example, that use of the
required Sun patented StarOffice-related technology for OpenDocument
should be protected by the Sun Covenant,
but reuse of the code with the patented technology
for non-OpenDocument implementations
is no longer protected by the related Sun covenant.

The OSP similarly can be used to freely implement
any of the covered specifications in OSS
but its scope is limited to the covered specifications
and cannot be used to transfer Microsoft patent rights
to other implementations of non covered specifications
for instance by using the technology in code that has a
patent transferring software license.

For this reason the SFLC has stated:
    "The OSP cannot be relied upon by GPL developers
for their implementations
not because its provisions conflict with GPL,
but because it does not provide the freedom
that the GPL requires."[8]

The SFLC specifically point out:
    new versions of listed specifications
    could be issued at any time by Microsoft,
    and be excluded from the OSP.
    any code resulting from an implementation of
    one of the covered specifications
    could not safely be used outside the very limited field of
    use defined by Microsoft in the OSP.[8]

The Microsoft OSP itself mentions the GPL in two of its FAQs.
In one it says,
    "we can’t give anyone a legal opinion about
    how our language relates to the GPL or other OSS licenses"
In another, it specifically only mentions
the "developers, distributors, and users of Covered Implementations",
so excluding downstream developers, distributors, and users of
code later derived from these "Covered Implementations"[8]
and it specifically does not mention
which version of the GPL is addressed,
leading some commentators to conclude
that the current GPL 3 may be excluded.[10]

    Q: I am a developer/distributor/user of
    software that is licensed under the GPL,
    does the Open Specification Promise apply to me?
    A: Absolutely, yes.

The OSP applies to developers, distributors, and users of
Covered Implementations without regard to the development model
that created such implementations,
or the type of copyright licenses under which they are distributed,
or the business model of distributors/implementers.
The OSP provides the assurance that Microsoft will not assert
its Necessary Claims against any entities who
make, use, sell, offer for sale, import, or distribute
any Covered Implementation under any type of
development or distribution model, including the GPL.
microsoft and freedomware arguments:
GrayKnowlton 2008`
A disappointing surprise from the SFLC

They say "The OSP cannot be relied upon by GPL developers
not because its provisions conflict with the GPL
but because it does not provide the freedom
that the GPL requires."
They go on to identify that "freedom" being linked to
the OSP being unsafe is because new versions of the specifications
could be excluded from the OSP in the future.

It is unusual for promises like the OSP to
automatically include every spec or all future versions
(IBM's pledge is exactly like ours).
The norm is for new versions to be added to them to be covered.
In the case of Sun's statement
new versions are automatically added only when they
participate in the development of the new version
to the extent that the OASIS IPR rules
would then obligate them to provide patent rights
under the OASIS IPR Policy.
None of these promises include future versions of the specifications
without any qualification.

Let's deal with the points one by one:
Irrevocable only for now
This section points out that the OSP only applies to
listed versions of covered specifications.
True, except that we have already committed to
extending it to ISO/IEC DIS 29500
when it is approved in our filing with ISO/IEC.
For ODF, IBM in their ISP takes the identical approach.
Strange how things that seem appropriate for ODF
are not appropriate for Open XML.

OSP covers specifications not code
Not true. The OSP is a promise to not assert
patents that are necessarily infringed by
implementations of covered specifications.
Like all similar patent non-asserts
(including the Sun and IBM versions for ODF)
the promise covers that part of a product that
implements that specification
(and not other parts that have nothing to do with the specification).
While the Sun covenant is silent about
conformance to the specification,
the OSP allows implementers the freedom to implement
any (or all) parts of a covered specification
and to the extent they do implement those portions
(also known as conform to those parts)
they are covered by the promise for those parts.
Contrast that to the IBM pledge that requires total conformance
and so programming errors or absence of
something required by the spec
(but not by an implementer's product)
means that the promise is totally void for that product.

No consistency with the GPL
Not true. As far as we are concerned
we are happy to extend the OSP to implementers who
distribute their code under any copyright license including the GPL.
The FAQ cited just states what everyone knows and acknowledges,
the GPL is a copyright license that is drafted in a way that
leaves many issues (not just those related to patent rights)
open to many interpretations.
Any particular user or implementer
should read the GPL carefully and make their own judgment about
what it means and requires
in accordance with their own circumstances.
The FAQ states that Microsoft is not in a position
to give blanket advice about the GPL to others.

They missed these two FAQs for some reason...

"Q: Is the Open Specification Promise intended to apply to
open source developers and users of open source developed software?
A: Yes. The OSP applies directly to all persons or entities that
make, use, sell, offer for sale, imports and/or
distributes an implementation of a Covered Specification.
It is intended to enable open source implementations,
and in fact several parties in the open source community
have specifically stated that the OSP meets their needs.
Moreover there are already a significant number of
implementations of Covered Specifications
that have been created and/or distributed
under a variety of open source licenses
as well as under proprietary software development models.
Because open source software licenses can vary
you may want to consult with your legal counsel
to understand your particular legal environment.
Q: Is this Promise consistent with open source licensing,
namely the GPL? And can anyone implement the specification(s)
without any concerns about Microsoft patents?
A: The Open Specification Promise
is a simple and clear way to assure that
the broadest audience of developers and customers
working with commercial or open source software
can implement the covered specification(s).
We leave it to those implementing these technologies
to understand the legal environments in which they operate.
This includes people operating in a GPL environment.
Because the General Public License (GPL)
is not universally interpreted the same way by everyone,
we can't give anyone a legal opinion about
how our language relates to the GPL or other OSS licenses,
but based on feedback from the open source community
we believe that a broad audience of developers
can implement the specification(s)."
Bruce Perens 13 Mar 2008 1:58 PM FUD
The fallacy in your analysis is that
SFLC would not like IBM or Sun's patent covenants either.
They oppose software patenting in general,
Moglen has been very clear about that.
The reason that GPL developers find it
legally possible to work with Sun and IBM
is that both companies have contributed directly to the
development of GPL and LGPL code
implementing the same standards
that their covenants cover.
Thus, they are not only bound by their covenants,
but by the GPL language regarding patents,
which unlike the covenants
do adequately protect GPL developers.
While there are differing opinions about the GPL,
it is the same for any license.
If lawyers never disagreed,
there would be no reason for courts.
GPL3, and the two other licenses using its text,
LGPL3 and the Affero GPL3,
became perhaps the most legally scrutinized
licenses in the world during their development.
Most of the major corporations in software
had their lawyers on the GPL3 committees,
as did many organizations like W3C,
and many other interested parties.
Because of the very large and diverse legal team
that participated in its development,
we can put forward the GPL3 family of licenses
as more legally "solid" than, for example,
Microsoft's own licenses.
But GPL2 has done quite well in this regard too
- although we hear of many cases being settled
in favor of the GPL developer by SFLC and others,
no defendant has dared to go to court.
We also have Microsoft's past actions to consider
when we look at its present promises.
Nobody can argue that the company has behaved in a
hostile manner toward Free Software developers,
for example spreading patent FUD about our software
and yet over a period of years refusing to
disclose the particular patents and the code
that Microsoft feels they cover.
The ballot-box stuffing that occurred in ISO
is another example of current reprehensible behavior.
So, of course SFLC should interpret Microsoft's promises
in the worse possible light.
   Bruce Perens
Bruce Perens 13 Mar 2008 3:32 PM
Gray Knowlton wrote:
"Bruce, if you could please post a link on my blog
to action that Microsoft has taken
against people who have developed solutions using Open XML,
my readers would appreciate it.'
"
[. the problem with that is land mining:
you haven't stepped on us ... yet .
]
This is a common rhetorical device.
You propose your own straw-man,
and ask me to knock it down.

Gray Knowlton further wrote:
"If SFLC would be opposed to IBM's
approach to ODF protection,
then their report on ODF would have indicated so.
There is no mention of the IBM promise.
"
I have read the SFLC opinion letter. It is very clear
that their opinion relies on the
Royalty-Free rules of the OASIS ODF standard committee
and Sun and IBM's commitments to comply with those rules
as contributing members of that committee,
not just upon the covenants.
Microsoft did not choose to submit OOXML to a
standards organization that asserts that sort of rule.

But we should not pretend that this is just a legal question.
OOXML is so large that a programmer can not be expected
to learn it in his useful lifetime.
Fully 10 times the size of ODF,
to represent the same documents.
That's just one more reason (and there are others as well)
that Microsoft's sincerity is in question
- the proposed standards document doesn't appear to be
meant to enable competing implementations.
Bruce Perens 13 Mar 2008 3:50 PM
Gray Knowlton wrote:
"IBM in their ISP takes the identical approach."
Actually, that isn't the case.
Only the Microsoft covenant has that.
IBM's covenant does not have any language
excluding later versions.
Sun's covenant explicitly grants rights to later versions.
Jesper Lund Stocholm 14 Mar 2008 5:16 AM
Bruce,
> IBM's covenant does not have any language excluding
> later versions. Only the Microsoft covenant has that.
If you look at the IBM patent pledge guidance
you will find the text:
"How will IBM address additional specifications
or new versions of specifications on the list?
IBM will evaluate new versions or
additional specifications
for inclusion based on their consistency with the
objectives of this pledge
which is to support widespread adoption of
open specifications
that enable software interoperability for our customers,
and may, from time to time, make additional pledges."
This is basically a word-by-word replica
of the intent of the text in Microsoft's OSP.
> Sun's covenant explicitly grants rights to later versions.No it doesn't.
If you insist on nit-picking the wording
you must include the part of Sun's CNS where it says:
... "or of any subsequent version thereof
("OpenDocument Implementation")
in which development Sun participates
to the point of incurring an obligation,
as defined by the rules of OASIS,
to grant (or commit to grant) patent licenses
or make equivalent non-assertion covenants."
Notice the part
"in which development Sun participates".
GrayKnowlton 13 Mar 2008 3:50 PM
The "Nobody can implement Open XML" argument
ends here: silverlight-viewer-for-open-xml
and here: openxmlcommunity.org .
The "Sincerity" discussion ends here:
motivation-and-commitment-to-open-file-formats .
orlando 13 Mar 2008 4:06 PM
ooxmlisdefectivebydesign/
bad-surprise-in-microsoft-office-binary
Bruce Perens 13 Mar 2008 4:15 PM
Gray Knowlton writes:
"Not only do we disagree with the words,
Open XML already has many, many implmenetations
(which include IBM, Google, Novell, Apple and others)
to show for it.
"
It is deceptive to imply that those companies
rely on the OSP.
They have patent cross-licenses with Microsoft.
So much for sincerity.
Bruce Perens 13 Mar 2008 4:58 PM
Gray Knowlton writes:
"as far as I know,
we have no interop agreement with Google.
I could be wrong, but I've never seen one.
"
You are not seriously proposing that Google
is at any risk of patent aggression from Microsoft.
Agreements under NDA may exist, and even if they don't,
Google has a sufficient arsenal of legal talent, capital,
and blocking patents on Microsoft's own activities
that they can enforce a detente, or worse, upon Microsoft.
Your statement, again, was:
"The article says that
  "Microsoft does not provide protection for
  Open XML with the OSP."
Not only do we disagree with the words,
Open XML already has many, many implmenetations
(which include IBM, Google, Novell, Apple and others)
to show for it.
"
It is deceptive to imply that any of those folks
- especially Google - have to rely on the OSP.
GrayKnowlton 13 Mar 2008 8:12 PM
Again, if you're implying that
Google or any other company (big or small)
has to enter into some special agreement
to implement Open XML,
that is inaccurate.
Google had an implmentation of VML in its Maps product
long before the Open XML discussion started anyway.
Read: apis/maps/documentation/overlays .
Fiery Spirited 14 Mar 2008 4:13 AM
>Well, Bruce, I don't think we have a "big rich
>companies" section of the OSP, I think it applies
>equally to big and small companies.
I do totally agree.
The OSP give equal non-existent protection
to small and large companies.
Like already told
the large companies have protection from other sources
so it is a minor problem for them.
You say that Microsoft will extend the OSP
to the updated dis29500
...fairly given, isn't it? Problem is just that
Microsoft have not committed to actually
implement dis29500
or the future versions of that standard
so the OSP covering dis29500 is pointless.
What is needed is:
* Microsoft must promise to implement
the _full_ dis29500,
including upcoming versions, if they should be trusted.
* Microsoft must extend the patent promise
to exclude the right to sell the patents to patent trolls.
As written only Microsoft itself is bound to
not use the patents,
and that is obviously not enough.
* Microsoft must craft a OSP so that
the protection apply to the GPL and open source developers
even if these are used for commercial purposes.
* Microsoft must publish all patents they have
that concern dis29500.
This includes the many patents that
Microsoft have requested
after OOXML approval process begun.
* Microsoft/Ecma should remove the
nonsense requirement that
syntactic compability is enough to claim conformance.
The past behavior of Microsoft
is not the reason people don't
trust Microsoft about OOXML
...it is the current behavior that is the problem.
Reject dis29500 is the only sane conclusion....
Unless Microsoft take the above actions
the following results are very likely:
* The ISO label will be used by Microsoft
to fool people into using Office
since it "supports" an ISO standard
* Office 2007 will never faithfully implement dis29500
so all files produced
will lack interoperability with producers that
don't rely on the Microsoft DLL files.
* Microsoft will sell the patents to patent trolls
to attack competitors.
* Microsoft will use all application-defined points
and undefined points in the standard
to break real compability.
GrayKnowlton 13 Mar 2008 4:27 PM
Stepping back for a minute,
do you see how hard Microsoft is defending
the IPR policy for Open XML?
Could you understand why?
-- it's not because we want to meet the goals of the process
(the ISO process would not have begun without
passing ISO IPR guidelines,
that was addressed a long time ago),
it's because we are keenly interested in
the adoption of Open XML.
Does it make sense for us to propose a standard
then prevent people from implementing it?
-- I don't think so.
Anonymous Coward 13 Mar 2008 6:17 PM
"Does it make sense for us to propose a standard
then prevent people from implementing it? -- I don't think so.
"
In a world where governments and others
are starting to demand standardized document formats,
does it make sense for someone with
near-monopoly situation
to propose a standard then
prevent competitors from implementing it,
maintaining status quo with the cash cow?
Oh, wait..
GrayKnowlton 13 Mar 2008 8:12 PM
. in a world where accountability and compliance
are mandates,
there is little room for games and slight-of-hand.
I'd give the government ageinces a little more credit.
Ray B. 13 Mar 2008 9:47 PM Gray Knowlton said:
"It's not "Trust me." Regarding the ISO process,
ISO is the organization declaring that Open XML
passed their bar for IP requirements.
"
I don't see Open XML passing the bar,
I see it as Microsoft attempting to buy the bar(ECMA),
because if Open XML fails fast track,
Microsoft risks there cash cow to
growing government ISO document requirements.
They can't risk ODF ISO/IEC 26300(approved 2 Years ago)
get any more support!
You keep asking for examples of Microsoft
taking action against somebody's
Open XML implementation,
I say its far to Early,
they are still working on the "Embrace".
Microsoft won't "Exterminate"
until Open XML is an "approved" standard !
This is business as usual for Microsoft,
"Embrace, extend, and exterminate"
Embrace XML on there terms
(Open XML not ODF ISO/IEC 26300 )
Keep adding "custom" Extensions
(With the all powerful "IP")
Exterminate any body who uses there precious "IP"
it won't be tomorrow, or next week ...
Looking at Microsoft's history, and current actions.
They don't look like a company committed to
interoperability/coexistence!
GrayKnowlton 13 Mar 2008 10:03 PM
XML support in Office arrived 8 years ago
(which means code was written 10 years ago).
And while you're out looking for for the
Open XML actions we're taking,
you should dig up the history of
binary format specification licensing
we weren't doing since 2003,
and dig up that long list of actions we've taken
in addressing the thousands of applications
that read and write the binary formats.

freedomware

7.18: web,news.adds/openware/
osi's open source definition:

. Stallman likes to call GPL'd wares, free sofware,
but the natural contraction of that is freeware,
and that is notoriously not GPL;
it's usually just a chance to get malware .
. I think we should call GPL'd wares
evolverware, or freedomware .
. in any case, you can't call it openware;
because,
"( the obvious meaning for
the expression “open source software”
—and the one most people seem to think it means —
is “You can look at the source code.”
That criterion is much weaker than the free software definition,
much weaker also than the
official definition of open source.
It includes many programs that are
neither [freedom-supporting] nor open source.).
I think it's important that we point out
that it's important to promote freedomware,
and to distinguish it from openware;
but we need to promote the use of vmware too,
so that we can use both freedomware
and malwares like drm-protected music .
. the most important freedomwares
are not only the os and compiler,
but also the hypervisor .
. if gnu ever gets around to an os,
it should be something like Qubes
only perhaps with the smaller okL4
instead of xen, if that is possible .

osi's open source definition:
. it's a lot like the gpl; so,
what's the diff?

Stallman`Why Open Source
misses the point of Free Software

...
The official definition of “open source software”
(which is published by the Open Source Initiative)
was derived indirectly from our criteria
for [freedomware] . It is not the same;
it is a little looser in some respects,
so the open source people have accepted a few licenses
that we consider unacceptably restrictive.
Also, they judge solely by the license of the source code,
whereas our criterion also considers
whether a device will let you
run your modified version of the program.
. their definition mostly agrees with our definition;
Nonetheless, there are situations where
these fundamentally different views
lead to very different actions.

The idea of open source is that
allowing users to change and redistribute the software
will make it more powerful and reliable.
But this is not guaranteed.
Developers of proprietary software
are not necessarily incompetent.
Sometimes they produce a program that
is powerful and reliable,
even though it does not respect the users' freedom.
[freedomware] activists and open source enthusiasts
will react very differently to that.
A pure open source enthusiast,
one that is not at all influenced by
the ideals of free software,
will say, “I am surprised you were able to
make the program work so well without
using our development model, but you did.
How can I get a copy?”
This attitude will reward schemes that
take away our freedom, leading to its loss.
 For the [freedomware] movement,
nonfree software is a social problem,
and the solution is to
stop using it, and move to free software.

Under pressure from the movie and record companies,
software for individuals to use
is increasingly designed specifically to restrict them.
This malicious feature is known as
Digital Restrictions Management (DRM)
(see DefectiveByDesign.org)
and is the antithesis [of freedomware] ...
And not just in spirit:
since the goal of DRM is to trample your freedom,
DRM developers try to make it hard, impossible, or even illegal
for you to change the software that implements the DRM.

Yet some open source supporters have proposed
“open source DRM” software.
Their idea is that, by publishing the source code
and by allowing others to change it,
they will produce more reliable software
for restricting users like you.
The software would then be delivered to you
in devices that do not allow you to change it.

This software might be open source
and use the open source development model,
but it won't be [freedomware] since it won't respect
the freedom of the users that actually run it.
If the open source development model
succeeds in making this software
more powerful and reliable for restricting you,
that will make it even worse.

. software can be said to serve its users
only if it respects their freedom.
What if the software is designed to put chains on its users?
Then powerfulness means the chains are more constricting,
and reliability that they are harder to remove.
Malicious features, such as spying on the users,
restricting the users, back doors, and imposed upgrades
are common in proprietary software,
and some open source supporters
want to implement this same malware
in open source programs.

Nearly all GNU/Linux distributions
add proprietary packages to the basic free system,
and they invite users to consider this
an advantage rather than a flaw.
the philosopher of the Free Software movement:
“Open source is a development methodology;
free software is a social movement,”
Stallman says in his book
Free Software Free Society:
Selected Essays of Richard M. Stallman.
“We are not against the open source movement,
but we (Free Software movement members)
don’t want to be lumped in with them.”
Open source-ers like Bruce Perens,
the author of the movement’s official definition,
believe that free and proprietary software can co-exist.
Perens, the author of the Open Source Definition,
called Stallman a great philosopher
but called his ideas “utopian”
and attributed them to Stallman’s
lack of success in the business world.
[7.19:
. actually, Stallman's ideas can be attributed to
Traditional Retail's lack of success:
. he had a printer and found a bug in its driver,
but the company didn't want to fix it because
bugs are what get you to buy the next model .
]
Richard Stallman earned a BA in physics
from Harvard University in 1974.
. accolades for his contributions include:
1990 ACM's Grace Hopper award
(extensible editor EMACS (Editing Macros))
1998 Electronic Frontier Foundation's Pioneer Award
(his 1984 GNU Project became significantly usable
when combined with the Linux kernel ); [7.19:
1999 Yuri Rubinsky Memorial Award.
(development of the Internet infrastructure;
he warned about software patents on basic ideas);
2001 Takeda Techno-Entrepreneurial Achievements
for Social/Economic Well-Being Award
(origination and advancement of
open development models for system software
- open architecture, free software
and open source software.)
... not to mention numerous honorary
doctorates and professorships
.]

Perens, author of the Open Source Definition:
is author of the Open Source Definition
and co-founder of the Open Source Initiative.
. he's been a computer graphics expert,
with 12 years at Pixar Animation Studios.
. Perens sees 3 software Paradigms:
# Traditional Retail
# Contract / In-House Development,
# open source. [7.19:
. the Traditional Retail Model is appropriate when
the software is automating professional services;
eg, tax filing software is acting as legal consultant,
rather than a computer resource manager .
. the software itself is rather trivial;
what you are paying for is expertise .][7.18:
. this software could still be freedomware
while the business rules were kept closed
in a pay-to-use database; ][7.19:
in fact, this software is all freedomware now;
it uses your firefox or chrome browser
to interact with an online service .]
. The Contract / In-House Development Model
gets its money from using software
rather than selling it;
and, using secret software
gives them a competitive advantage . [7.19:
. that doesn't mean it can't use freedomware:
the spirit of Stallman's GPL is that
if you put software on any of my devices,
you have to give me the source code,
and allow me to change the software on my devices;
so, an online service can
use freedomware on its own servers
without giving you the code;
therefore, it can use GPLware
and still keep its in-house software a secret .]
Open source’s primary advantage,
is creating non-differentiating software [7.19:
that is producible by non-experts .]
By distributing these types of programs as open source
it is possible to share the cost and risk
of development among many parties.
. anyone who is interested in the software
can participate in enhancing it,
sharing the overhead of software development
and saving costs all around.
7.18: co.adds/openware/GPL owes legitimacy to OSI?:
Summary:
. OSI, an important, but long quiet,
open-source organization
is seeking to revitalize itself with a new
membership program.
By Steven J. Vaughan-Nichols
for Linux and Open Source | July 18, 2012
-- Updated 17:31 GMT (10:31 PDT)
Portland, OR:
There was a time that everyone in the
Linux and open-source world
knew about the Open Source Initiative (OSI).
It was, and still is, the group which manages
the Open Source Definition.
This is the core open-source defining document
for developers, governments, and businesses.
All the other open-source licensees
— Apache, BSD, GPL —
all[owe] some of their legitimately[legitimacy]
to  the OSI.
In recent years, though, the OSI has laid fallow.
Now, it wants to change that and once more become
a vital part of the open-source community.
me:
GPL owes legitimacy to OSI?
. the honourable Richard Stallman, founder of GPL,
has philosophical differences with OSI,
so I think you owe us an explanation
after asserting that
"All the other open-source licensees
—Apache, BSD, GPL—all[owe?]
some of their legitimately[legitimacy?]
to  the OSI."
. OSI is "the core open-source defining document
for developers, governments, and businesses" ?
. what does that have to do with GPL's legitimacy?!
. what legitimizes a legal document
is enforceability, and attractiveness;
do you know how large the GPL base is?