So simple as it is:

Notes

Access rights, user permissions and etc. is always related to a target as my colleague Simeon said while we’ve been discussing the above problem’s crafting.
So the solution is better described as sentence

Who has what kind of permissions upon which target data/action/tool/feature & etc…

The same structure above can be even cleanly represented as this object graph/map:

The above I suppose can be well implemented in any kind of DB and optimized to work perfectly, however I would use graph-like DB (neo4j) if I go for a stable/scalable solution at first place.

And here is it obi.wizartworx.com with a new theme… Still polishing some bits & peaces of the theme, but it is wonderful well done job by ravisama

Just wanted to log down the time and hour of seeing how far wordpress had gone so far… In the beginning it didn’t updated automatically at all, today it gives you a feature to browse/preview and to try hundreds of themes… And that is not “wordpress” success only, it is to the ‘crowd’ itself.

1 Hour later I was still clueless what is the public reaction except that when I opened a twitter search on “github” I was flooded with various tweets all around one thing -> “github’s outage”.

After 30 mins of searching I found several solutions:

• http://trendistic.com/ – is cool but not realtime enough.
• http://mashable.com/2009/04/04/twitter-trends/ – has a nice collection of tools but unfortunately none of them feels like the one.

So I decided to mockup one of my own:
twitter trended search chart

Source code is of course on github

The solution is as simple as this:
1) on regular intervals (currently on every 1s) a request is made upon twitter search
2) returned results count is captured as Y axis value and the elapsed time from the initial submit as X axis value. All other requests been made to twitter search use “since_id” attribute to fetch only the new coming results on first page, where if the last since_id is equal to the current received one: it is assumed that the incoming results count is a new hit.

Based on the above mockup it is fairly easy to track & monitor twitter trend in realtime. I’ve tested the web app during the github outage and it prooved to be useful (there was a peak of around 60 tweets at that time)

However there is still something which should be kept in mind – the trending search chart is a proof-of-concept, not real life utility

PS. I would like to point that the mockup is build using componentjs which proved once again that using component based development in html/js is possible and highly effective.

**Update**
I’ve found one other service providing at least charts of the activity in twitter per trend, however it is still not realtime:

• http://www.crowdeye.com/

Would like to see at least one of the services targeting twitter as platform to implement realtime trend activity charts. TweetDeck for example

• clumsy looking SimpleChrome Extenstion for in browser based adding but without the searching UI

• clumsy looking SimpleUI for web based adding and searching.

• Decentralized logic architecture but centralized database location for the tags <-> links relations
• Tags autocomplete support
• Tags auto identify support when adding links
• open source

Tomorrow*:

• Realtime stream via twitter (streaming as @devsunited until more appropiate account is choosen)
• Realtime stream via XMPP (should be invited at XMPP servers remotely first)
• Technologies/links dependency system (still in construction…)
• Technologies genome view (realtime graph-like map of technologies and their dependencies, similar to http://geni.com & http://familyone.de but for technologies)

Tomorrow is ironically used. I’m fully aware of the scope for the above statements as well as that contributions,ideas and united work are more than welcome.

Here is how single RESTful test looks like using twillRest:
assertGetContains something http://domain/user/1
assertPostContains something http://domain/user/1 field1=value1&field2=value2
Features:

• Quickly write down functional tests
• Add support for state maintaining via custom response parsers
• based on twill (and thus supports twill-fork)

There are of course others functional and unit test frameworks for python but as I needed something simple and just working – twill looks like the one. Once twillRest is upgraded with true REST client like (http://code.google.com/p/python-rest-client2/) it will became even more usable (alghtough I’ve used it in production already)

• Download eclipse helios http://www.eclipse.org/downloads/packages/eclipse-ide-javascript-web-developers/heliossr1
• Install Pydev plugin from Eclipse Market place (innovative plugin install… I’ve used the Yoxos macketplace because the ‘default’ one failed)
• http://code.google.com/appengine/downloads.html#Google_App_Engine_SDK_for_Python (google app engine)
• http://pydev.blogspot.com/2009/05/testing-on-pydev-146-google-app-engine.html (eclipse & google app engine, unfortunately without django)
• Create google app engine project from “New -> Other” using pydev
• Create django project using “django-admin.py startproject project” withing the root of the created project. Move the django generated files directly under the ‘src’ folder
• Follow http://code.google.com/appengine/articles/django.html
• Useful
  • http://code.google.com/p/python-rest-client/wiki/REST_for_Google_App_Engine
  • http://code.google.com/p/appengine-rest-server/

Pay attention to the settings.py file as from it comes a lot of errors before django get properly running under GAE. Quick and Stable.

Update:

Actually for a simple web service implementation one may use simple frameworks like Bobo .
It is simple, fast & easy as just following http://blog.d2m.at/2009/06/22/bobo-gae

Keywords:

“browse software technologies map”

“software technologies browser”

Results:

http://opensourcegis.org/ ->

This effort represents an attempt to build a complete index of Open Source / Free GIS related software projects. The effort has some way to go, especially for projects in languages other than English. The definition of GIS has been kept loose to encompass a broad range of projects which deal with spatial data.

and while digging in found http://wiki.gis.com/wiki/index.php/GIS_Software_Technology which indeed is quite nice representation of software (development) evolution atm:

Indeed that is the way “it” goes…

keywords:

“browse software libraries”

“browse software libraries map”

“software libraries browser”

As well as any other combination between the above returns results without a solution on

how a software developer can view/search/query/navigate within current state of software technologies (at least web ones ?

Google for them… But those “new” onces? Twitter?

As side note I’ll describe mine approach atm (which I’m trying constantly to improve imho) in newest to latest order:

1) follow twitter (http://twitter.com/obiwon/webtechs)

2) http://github.com/explore

3) follow amazing number of RSS feeds (web related blogs, magazines, persons & etc…) As one may say “You name it, I’m reading it.”

So all those three give me constant flow of 24/7 information. It is “huge” (meaning if I need to include side flows like facebook, email groups & others)

And there is no single service which would combine those all into one meaningful chaotic rendered map of software technologies been developed before, today & maintained tomorrow ?
Here are some of which I would like to have bits & peaces:
http://en.wikipedia.org/ – it has the data per every mature software technologies out there. Detailed one in some cases, short in others. But it has it at some extended at least.
https://github.com/ & http://sourceforge.net/ & http://www.codeplex.com/ & … (well they are a lot http://en.wikipedia.org/wiki/Comparison_of_open_source_software_hosting_facilities ) – they all hast the actual source of the technologies
http://www.ohloh.net/ – here are the stats (or at least how they should look like in general)

Alternatives & Additions grow as time goes by atm. So it won’t give any result in numbering them here (try googling )

So the data is actually there. But it is just not centralized & presented in nice manageable user experience. At least it takes hell a lot of time to keep track and in the same time test/evaluate/will not mention contributing as it goes out of the scope… So here is a challenge.  And here is a architecture for how I think things may happen:

It is not final at all. But hopefully gives major idea on what I envision as “to be able to browse for software technologies” at least. And they are really quite big number to be browsed at once. But at least to be able to follow and research the trends or “new comers” would be nice feature. So here are the use cases (at least in the beginning):

At the above use case isn’t shown the following (which has been considered useful in long terms system implementation):

- Technologies Browser web interface is user frontend application. It is not strictly said that only one will exist, but at least one will

- Security & Moderation aspects on the topic are left outside of this scope to keep things simple & evolution ready.

Keep things simple right? Who knows what is waiting us around the corner

First an technology/platform should be selected on which the frontend will be written. Possibilities so far:

- Flash
- Silverlight
- Java Applets, Java FX & family
- HTML & JavaScript

Because Flash is widely distributed across the net – I’ve started mocking up the prototype right there, but after 1 day of trials, performance improvements & etc I ended up with something which wasn’t quite good as I expected:
http://wizartworx.com/hSourceEditorInstance.air (there is used optimized version of http://code.google.com/p/as3syntaxhighlight/ )

As you can see the end result isn’t fast enough to support hundreds of source code lines. So eventually flash platform isn’t suitable for implementation of robust fast performance code editor. So I questioned myself – what platform eventually will go further than its current state. Silverlight is great, Java too, but all of them actually are plugins and “workarounds” to features which web browser does not has. And with the ongoing HTML5 integration this “workarounds” actually won’t be needed anymore. And a proof for that is these path links which I’ve gathered during the research process:

demos:

• http://3.paulhamill.com/node/39
• http://www.whatwg.org/demos/2008-sept/color/color.html
• http://xant.us/ext-ux/lib/ext-3.0.0/examples/desktop/desktop.html
• http://jeko.free.fr/megapong/
• http://demo.nextapp.com/echo3csjs/
• http://glimr.rubyforge.org/cake/redesign.html

some highlight libs & editors/components:

• http://mihai.bazon.net/projects/javascript-syntax-highlighting-engine
• http://code.google.com/p/google-code-prettify/
• http://marijn.haverbeke.nl/codemirror/
• http://shjs.sourceforge.net/
• http://guillaume.bort.fr/textile-editor/index.html

frameworks:

• http://sproutcore.com/
• http://prototypejs.org/
• http://sizzlejs.com/
• http://www.extjs.com/
• http://www.gapjumper.com/
• http://labs.adobe.com/technologies/spry/home.html

And many many more implementations on the pathway.

Conclusion

I’ll leave this section without stating my own opinion, but one is for sure -> HTML5 will change the way how browsers interact with the web, not by themselfs but generally as how developers implement it.

So as been curios what is going on with the head line of development turned to Github & Google Code . Sadly didn’t found anything covering my expectations (the same situation as DAssistA though). And while still been curious how other people handle working together in easy enough convenient way decided to give a try to the history:

Project management is the discipline of planning, organizing, and managing resources to bring about the successful completion of specific project goals and objectives. It is sometimes conflated with program management, however technically a program is actually a higher level construct: a group of related and somehow interdependent projects.

And while quick-cross-referencing the information there I stumbled upon the Extreme Programming which in that light is simply told as:

Extreme Programming (XP) is a software development methodology which is intended to improve software quality and responsiveness to changing customer requirements.

Interesting thought we use “agile methodologies” all the time, even in a more huge time-laps like in “Phased” methodology used a couple years ago. Or as it is now – everyone looking forward after XP and its frameworks (Scrum). One thing which made me not believing in those methodologies as immediate future for project _development_ is my everyday work using them. Also looking towards the incoming era of open cloud – source it is fairly reasonable to see that those tools & methodologies need more… But what?

And then moved to the next one PRINCE2 – methodology having only one year live. Well I’ll leave it without comment… But this (which is older than me) grabbed my imagination – PERT.
PERT is not a methodology as the above mentioned onces, nor it is something new – but all in all it is what every single project been developed nowadays is:

commonly abbreviated PERT, is a model for project management designed to analyze and represent the tasks involved in completing a given project.

So once the project has its tasks, team, goals & all other pre-requirements it can start. And then things get sometimes very ugly – complex tasks relationships, human errors causing reoccurring tasks to became issues and a lot more of the same manner as you may be experienced once in awhile been involved in project development. Naturally projects & their management accordingly their development will evolve, so I questioned myself – “how?”.

Took me a while to dig all those, but anyway they all have a same thing and miss another.

• streber/Project overview – streber
• Features | Open Atrium Customized Home Page Increases Small Business Productivity – OnePlace
• qdPM – Project Management, Time Tracking, Support Tickets, Open Source
• Project.net | Project.Net Tour
• DeskAway – Online Project Collaboration Features – Milestones, Tasks, Issues, Time Sheet, Upload Files, Docs and more…
• Open Workbench – Home
• TaskFreak! web based task manager and todo list, project management made easy
• OpenProj | Serena Open Source and Hosted Project Management Software
• Project management, requirements, collaboration, and task software: Endeavour
• Gtdagenda.com
• Unfuddle: Subversion Hosting, Git Hosting, Bug and Issue Tracking
• TimeWhale – Online Time Recording, Tracking and Management Software
• LiquidPlanner – Online project management software, scheduling, collaboration, tracking
• Quick tour of COMINDWORK – Online Project Management, Knowledge Sharing and Collaboration Free Software

So how should look like Issue/Task Management System for projects (not programs) in the future? What should be its features, requirements & _purpose_? Will it help people to communicate more easily over complex inter-related work to be done?

All those questions are still open to me. But one is for sure -> the picture should change…
Mine proposal is to visualize those as graph I’m totally against tables & lists (after all the UI will change as the input goes multi-touch isn’t it?).

At last after a loooong several hours digging and (re)searching how to setup my ubuntu(9.04 32bit) workstation to be able to develop in somehow _avarage_ speed I found a way doing it so with Flex Builder for Linux alpha 5 (and hopefully there will be alpha 6 supporting fully Flex4 .

I’ve lost around 2 hours to understand why Flexbuilder can not debug Flex4 based AIR project, when suddenly I’ve opened project’s “.actionScriptProperties” file and found what really was happening preventing me with all of the possible errors found during such setup…

So the problem is in the target version which was used (Flex Builder for Linux is generating air template projects for flex 4.0.0 sdk using ‘old’ .actionScriptProperties file, a template one you can get from the attached template-workspace-0.1-bla.tar)

And here are the essential parts which needed me quite a lot of time to figure out (may be one day this all will be one click setup?)

0. Ubuntu 9.04 32 bit with java installed (there are a lot of tutorials, mine is just to select its as package via Applications-> Add/Remove UI)
1. You need 32bit Eclipse 3.3.x (extract, mine is /home/outbounder/eclipse)
2. You need Flex Builder of course (run as normal console application ala “ALT+F2 – > xterm”)
3. After that you need all the sdks for development:
3.1 flex 4.0
3.1.2  (optional) I still work on flex 3 projects, so sdk 3.4 is needed)
3.3 Air SDK is needed, where strangely for one day I encountered several changes resulting in such download page at this moment (2010.03.17, 2:07 am)

4. Extract flex 4 sdk to install location of flex builder (mine destination  is at /home/outoubnder/flexbuilder/sdks/4.0.0)
5. Extract AIR sdk on top of flex 4 sdk destination folder
6. Rename adl & adt (those are located at the ./bin folder of the flex 4 sdk destination folder) to adl_lin & adt_lin

7. Fire up eclipse, add flex 4 sdk (more info here)

8. You can use the above mentioned template workspace for flex3/4 +/- AIR projects

9. You’ll need to follow also the instructions for installing Adobe Flash Player 10 — Debugger Version. as well and for even faster coding -> snippets

And now I can dream of abstract GUIs managing complex data relationships…

What you may expect from it in the near future is actually what ABN concept stands for: a lot of re-usable apps talking to each other… But now – coming with modular & scalable API for apps/bots communications through several channels first to be supported:
- REST
- XMPP

… next to come – who knows

I have to note that the repo includes some external tools which licenses I’ve didn’t found/included yet, where this will be done for the next major release of DAssitA’s repo 0.1.

Let’s get started:
Minimum requirements:
- Windows 7 OS
- Adobe AIR runtime installed

You can download the repo_0.0.7

And here are the steps required to get it moving:

0) unzip the downloaded repo to a folder where appropriate (mine setup is that the repo is extracted at D:\pd-repo\)
1) install haxe compiler with batteries included from here
2) install last revision of ActionPdmlToolbar
3) install last revision of PdmlEditor
4) to be able to use Svn module – install slick subversion command line client
5) add to your apache  new virtual host pointing to your unziped repo root folder using similar to this syntax:

<VirtualHost *:80>

    ServerAdmin webmaster@pdrepo.dev
    DocumentRoot <<YOUR PATH TO THE REPO's ROOT FOLDER>>
    ServerName pdrepo.dev
    ServerAlias pdrepo.dev
    ErrorLog pdrepo.dev-error_log
    CustomLog pdrepo.dev-access_log common
</VirtualHost>

Note that pdrepo.dev servername alias should not be changed, otherwise ActionPdmlToolbar & PdmlEditor won't boot.

6) add the following entry in C:\windows\system32\drivers\hosts file:

 127.0.0.1 pdrepo.dev

7) enable mod_neko2 for your apache by placing the following in httpd.conf:

LoadModule neko_module "C:/Program Files (x86)/Motion-Twin/neko/mod_neko2.ndll"
AddHandler neko-handler .n

place the ndll file from <<repo>>/haxe/org/dassista/tools/Prc.ndll to your neko directory

And that you go.
To test is DAssitA is installed properly try the following:

1) launch ActionPdmlToolbar
2) open explorer to <<repo>>\haxe\org\dassista\_pdmls\
3) drag the file compile.pdml to the ActionPdmlToolbar
4) double click on the compile.pdml entry from the action toolbar and see that there are no exceptions or anything scary outputed (usually compiling DAssitA itself requires around 5 to 6 secs and should ouput only empty lines)

DAssistA shell can do only one thing: invoke & pass any command line arguments to specified multi-module.
DAssistA rest can do only one thing which is the same as the shell, but made in rest-like context via http request/responses

ActionPdmlToolbar can do only two simple things:
- list  available (cached) pdmls & triggers their parsing/execution also providing feedback as pop up window.
- list available runtime modules returned by ModuleInfo impl. & trigger their execution.

PdmlEditor can do only one simple thing:
- edit pdml files. Currently it supports drag & drop operations for all available runtime modules returned by ModuleInfo impl.

So far so good.
There are still some little issues which should be fixed before new repo release can be made + engaging auto-update features for both PdmlEditor & ActionPdmlToolbar.

One of the biggest challenges so far is to build ‘universal’ application while keep the code needed to minimum, where this is so far hard near to impossible  even for so simple things like fast & cross-platform command line invokes… But all this soon will be past

Graph oriented data persistence is just the beginning of AI

That’s all it goes…

Just try the new repo_0.0.4 and give it to your imagination (or try something like “parse.bat asdkjahda” and after that open up haxe.org.dassista.tools.Parser at method execute )

More to come:
- full code documentation during the following couple of releases
- ftp upload(scp)
- wget tight implementation
- a nice GUI….