Menu

Show posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.

Show posts Menu

Messages - unixtechie

Pages 1 2 3 4 5
#31
newLISP newS / DekuDekuplex is right
March 24, 2009, 09:48:55 PM
Unfortunately, the two long-timers on this forum fail to appreciate one important factor, that of VISIBILITY and CONNECTEDNESS.



In a different place I have been an active participant in a very tightly connected "universe" of blogs. The site  is not just a hosting of individual blogs, and not simply allows visitors' commentaries in those blogs, but CONNECTS them through  a "friends reel" of a sort. With a huge mass of users this blogging engine becomes a qualitatively different beast, completely different from pseudo-blogs by the likes of university professors (which do not typically allow even commentaries) or political semi-official propaganda men.

Connectedness turns the site into a kind of universe in which news propagate according to new laws (which I tried to figure out and plot as huge graphs with hundreds of thousands nodes).



Newlisp is vastly underappreciated because it LACKS VISIBILITY.



I (it seems) convinced Lutz to advertise on http://www.freshmeat.net">www.freshmeat.net, the largest site for open source software, but still, in spite of my prodding, he does not do it aggressively (i.e. with each addition of library scripts etc); he was even talking about splitting announcements in two, one for newlisp proper, and the other one for libs.



Now we see the sort of semi-resistance from newlispers who got used to cloistered existence, and a  tiny handful of friends on a remote and disconnected forum.

Nope. When my blog (general interest, non-programming) on the site I talked about reached 1700 subscribers, I became a news organization of my own and by making searches I could track the texts I created and see how much they spread over the Internet and are amplified with lots of people picking the topic and developing it further.



Living among an established community of enthusiasts, in a central place where each newcomer would think of coming first, rather than wandering blindly and hitting coincidentally, and being a well-connected node in the graph of the Small World (a technical term in graph theory) the Web is gives a QUALITATIVELY different, non-linear increase in propagation.

Check some popular explanation of Small World properties and the different roles of nodes depending of their connectedness, and you'll see it for yourself.



So, whether as a separate newsgroup or as a constant presence in the most populated LISP group on Usenet, newlisp should exist, and I would applaud the efforts of the first poster and fully agree with his appreciation of newlisp as having a good potential to become very popular scripting language due to its size and self-containedness on top of the powerful capabilities of lisp.



/*

As a sort of illustration - this forum did not allow me to insert images directly - check the two animated GIFs, side by side, in one of my (smaller) blogs. Those illustrate the "ideal" propagation of a news item on a full graph, which looks like an explosion, and on a graph with well-connected nodes eliminated.

That shows you visually how different behaviour of these two types of nodes is

http://muzyka-sfer.livejournal.com/1350.html">http://muzyka-sfer.livejournal.com/1350.html

*/
#32
newLISP newS / Can be announced through Freshmeat, too
March 02, 2009, 02:30:29 AM
Lutz,



add this as an announcement to Freshmeat. You could do it under the same Newlisp entry (just write "new HTML canvas-t module" in Changes and add direct link to the page, if necessary) not to split the audience.



Growth of audience happens naturally with each announcement. As we saw, one entry provides approx. 300 visits to the home site (if we are to take the freshmeat stats as complete and representative)
#33
newLISP newS / Stats
February 20, 2009, 12:15:37 PM
http://freshmeat.net/project-stats/view/72153/">http://freshmeat.net/project-stats/view/72153/



Actually, it's

   Record hits: 615

   URL hits: 295

   Subscribers: 2

overall now
#34
newLISP newS / How many downloads did the site get?
February 15, 2009, 05:36:54 PM
So by now the stats are:



Record hits: 360

   URL hits: 219

   Subscribers: 1



That's not bad numbers for an exposure on the slowest day of the week, a Sunday.

If Lutz keeps a counter of downloads on his web site, it would be interesting to see how many downloads that resulted in



... and the thing now is to repeat the process as often as is possible - whenever any changes happen, a minimally modified entry (with only "Cnanges" section renewed) should be resubmited. And preferrably on a tuesday-wednesday, which are the fastest days of the week, judging from a general attendance stats of social etc. websites.
#35
newLISP newS / sourceforge versus freshmeat
February 14, 2009, 09:38:53 PM
Freshmeat is teh largest open source depository on the whole web



sourceforge is unreadable - or, let's say, was unbrowsable and is only in the process of changing that (or at least that is my impression), while "freshmeat" daily "newsreel" is excellent and is read by thousands.



Sourceforge deals only with projects it itself hosts, while Freshmeat announcements concern any software wherever its home page lives.



Sourceforge does not (as far as I remember) re-announce each update in teh project, while people using Freshmeat as a rule do exactly that.



And basically, a huge percentage of projects hosted on sourceforge is actually advertised through freshmeat. I know because I made it a daily routine to read the day's portion of freshmeat announcements  - to keep up with what is going on in the Open Source world, and have been doing it, well, maybe for 10 years or so.



There are quite a lot of insignificant scribbles there, yes, but ALL the MAJOR ones are announced on freshmeat.  This daily reading allows me to surprise people in conversations - e.g. recently I spoke with an IT manager in film industry who paid a lot of money for a custom Sun solution for a film digitization and storage problem, who (to give one example) was unaware that open source PKI software exists.

Regular reading of freshmeat gives you an enourmous power to construct solutions from components rather that writing them from scratch or blindly following commercial boasting and self-ingratiations (I still remember a catalogue of  avoidance techniques some representative, also from Sun, displayed when I was asking him for performance figures of their "corporate mail" product, as compared to well-known open-source MTAs like postfix or qmail.)



So freshmeat does make sense, in my view. Sourceforge is just a storage facility, as far as I am concerned



P.S. and as any political manipulator knows, if you repeat it, they'll remember and believe you.

So the better tactic is to repost the announcement with the tucked very short "Changes" at every tiniest change in the documentation and at every minor version upgrade.  This will maximize the impact.



P.P.S. ...not mentioning the fact that both sourceforge and freshmeat now belong to the same corporation (they have that interesting regime in the US when any company, if it grows to a certain degree of visibility must be incorporated in which process the ownership/governance changes hands and passes to the "big guys",  the banker's capital, to simplify a lot - in spite of the usual pretence of "private ownership" by many small guys etc. It has happened with the open source depositories now, too. )
#36
newLISP newS / Should Newlisp be announced "for real" ?
February 14, 2009, 11:48:11 AM
An interesting post, but that's just one man more.



Well, if we want a real growth in newlisp use, then newlisp MUST be announced on http://www.freshmeat.net">www.freshmeat.net



Then the situation will change forever: it's probably the central depository of open-source software, and visibility at that resource is absolutely indispensable.
#37
newLISP newS / even simpler
February 07, 2009, 02:23:02 AM
Quote from: cormullionI ......  found a mechanism to do it (assign a class to each element in a section, and change the style of each class using Javascript) that didn't otherwise alter the appearance. Since the HTML is generated by newLISP, it wouldn't be hard to add the classes.


Err.. the basic building block of this "folding" is in setting the style of each element (there's no need for "class", you can have JUST unique IDs for toggling), toggling between element.style.display="block" (that is visible) and "none" (that is not)



Change in appearance in no way is connected to this function - I simply cut your embedded stylesheet and put in mine. You can keep yours, just change the headings to trigger the toggle as in teh sample files, and refer them to unique element IDs (in "div"s, that is easiest) :



.. where "toggleDiv" can be defined once in your page "head" or inlined with each invocation, it's small.



You'll have to keep a bit of tracking for nested folding to work, i.e.. figure out where the higher level which wraps inned subsections actually ends to put your closind </div> there, though



But my script does not NEED to change your formatting into those "fieldsets" at all. I did it just because.. ;))



I also generate  the "folding TOC", which opens/closes sections from the TOC, and an index of code chunks with can be traced to the TOC sections  (as this is used for formatting source code with commentaries in a literate program), but that most probably is not needed in case of doing simple folding docs.
#38
newLISP newS / ;))))) don't worry, the forum is OK
February 06, 2009, 05:49:11 PM
no, I deleted it myself ;))))))))



But if you liked the formatting, let me recap what was written:



I suggested another format for NewLisp documentation and offered 3 files (the Manual/Reference, Code Patterns and cormullion's Introduction) as examples



This formatting turns every section marked in the original HTML file with "h1", "h2", ...  into a "collapsible" or "folding" section: click on the title and it opens.



So the document becomes a sort of TOC of itself, and the major convenience, as I perceive it, is that one does not have to keep a huge document (800k or more) open in his browser window, but only view what he needs.

Which provides a sort of "bird's eye view" and clarifies thinking according to my homegrown theory.



I use these views on my source code when writing scripts/programs and wrote a script that dynamically creates them.



So this format is just another derivative format from the "main" full HTML source, which one does not need to change, really (a couple of inconsistensies for the automatic script to make clean output).



If you like it, put it as a sample, as an alternative view on your web site (the file I sent you is a drop-in in your "Introduction" file structure), and let's see if others find the format useful.

If so, I'll give you guys the script to create it, and we'll just have one more derivative formatting for the documentation.



Let others see it and voice their opinions in this thread.



P.S. -- and cormullion you do not need to do anything, really.

I have a script (in Perl) that does it automatically.

So let me e-mail the samples again, and I'll give you the script to create them from your documentation then too.



P.P.S .. although if you want to rewrite the script in NewLIsp I won't hold you from that  ;))

The script basically substitutes each "h1", "h2", ... with a reference to a simple javascript function, while giving the sections unique numeric IDs.

The closing links require a tiny bit of calculation to keep track which of a hierarchy of enclosed foldings they toggle

That's basically it. Plus insert your own formatting style -- /style in the "head" of your generated HTML file (can be a default inside the file and a reference to an external css in case you supply one), if you need that at all
#39
newLISP newS / Databases and query languages
January 12, 2009, 01:54:11 PM
1. This is an exciting topic. The fact is THERE IS A SIMPLE DB TECHNIQUE/architecture that is roughly an order of magnitude faster than an SQL database in its typical applications (e.g. as a backend to a web application).



We can do a different and efficient newlisp-native DB if we code operations on columns only, rather than on tables of rows of data as it is done in SQL.



In fact, there exists currently a very interesting research project, a smallish database (think of MySQL before it achieved its corporate status), which implements column-based operations internally, but presents the user with SQL as a query language.

This database is open-source and available for download. My test run of TPC-H confirmed that this DB is roughly 10 times faster than MySQL, and it also eats up less memory: one won't be able to run the 1GB-scaled version of the benchmark on a machine with 1 GB of memory for MySQL, but it would run easily for the column-oriented DB.



It's easy to understand and prototype column operations even with shell utilities (and it's possible to do them in NewLisp, of course).



But this is only a first part of the story





2. There exists a simpler, more logical language to describe operations on data than SQL. Advocated by a university professor from the Low Contries, this approach seems to be dying now, after the demise of its author.

The language today lives only in an open-source tool that allows one to create databases and operations on them in this simpler language - and then translates them into SQL (for any of a wide number of subformats, e.g. Postgress, MySQL, Oracle, and even slqite).



The fact is the database product that the author of this concept created was also column-oriented, and therefore this simpler language is perfectly matched for a column-oriented approach.





So, this is a very interesting task, and I'd do this native scripted DB for NewLisp as a number of column-oriented operations, which might be presented to a user either or both as raw column operations, or as a set of SQL statements.
#40
newLISP newS / Buggy thinking ;)))))
December 24, 2008, 01:38:17 PM
Quote
Damm!
Code Select
(cond ((= 0 (% i 15)) "fizzbuzz")
Looks like cormullion beat me too it!!!


It's very wrong to use and hardcode "3*5" into this solution.



Supposing the numbers you were given were something like 6 and 15. Your program would think it should check for multiples of 90, while in fact it's multiples of 30.



To correctly solve this you'd have to decompose the given numbers into their (don't know proper terms in English) the prime numbers and find the smallest common ???



Unless you want to do it, use a clean reasoning scheme which generalizes without introducing bugs
#41
newLISP newS / perl is - sixfold - to twice - as fast in this test
December 24, 2008, 04:12:26 AM
Yours looks nice because of the minimalism you got through using an output accumulator instead of direct logic.

..a slightly modified version with "lazy generators" instead of modulo division


Code Select
(set 'step3 3)
(set 'step5 5)
(set 'lgen3 step3)
(set 'lgen5 step5)

( for ( x 1 100 )
 ( set 'acc "" )
 ( and ( = x lgen3 )  ( push "Bizz" acc) (inc lgen3 step3))
 ( and ( = x lgen5 )  ( push "Buzz" acc) (inc lgen5 step5))
 ( and ( = acc "" ) ( push ( string x ) acc ))
 ( println acc )
)
(exit)
Versions in which logic is used (rather than string operations) cut appr. 1-2 second(s) per 1 million iteration loops:

your version runs at 14.28 sec

yours modified  at 13.75

and the one with logic plus "lazy accs" in place of modulo division is at 12.6 seconds on my machine



The unpleasant thing however is that perl does this script verbatim (i.e. the same 1 million iterations) in 1.7 seconds (!!)



If I switch off output buffering in it ($| = 1;), the time increases to 6 seconds.



Newlisp does it approx twice as slow.  -- Why?
#42
newLISP newS / A truly functional solution. Anyone?
December 23, 2008, 11:58:13 PM
.. but there was in this company in the farthest corner of the room where all programmers sat a tiny office, and it was occupied by an old grumpy unix geek, who was actually the company system administrator.

As his servers buzzed on for the third year without a single reboot and his monitoring scripts notified him of the problems about 15 minutes before they happened, he had all the time on his hands to play with his favourite geeky toys. And one of such toys was functional programming.



So in half the time it took the company testing department to discover that typo in the customer report which turned an innocuous phrase into a grossly indecent one (slashing the company revenues and resulting in a couple of lawsuits by enraged budgerigar owners, all luckily settled out of court), he produced his own truly functional solution to the Fizz-Buzz problem.



It ran like this:
Quote
The input stream (potentially infinite, but reduced to the first 100 numbers for the sake of testing) is processed lazily, i.e. one item at a time.

The program runs 2 lazy generators in two coroutines, one spits numbers which are consequtive multiples of 3, the other one bakes  multiples of 5 (or any other given numbers). So, once the generator is kicked, a new member of the virtual "list" is generated, the next multiple to check against.



The main program therefore checks each input value from that (infinite) input stream for _equivalence_ with the current 3-list and  5-list members by ping-ponging to the coroutine.

Once the equivalence is found, the 3-list or 5-list generator(s) lazily produce a next number for comparison.



But, to speed things up and save on the coroutine invocation, the numbers from those lazy generators are of course memoized, thus cutting up the needed time and improving performance


Everyone marvelled at the sight of the sysadmin prog crunching Fizz-Buzzer player numbers in the gazillions and the generality of the solution allowing it not to slow down even if 312345912358 and 512309482093481209358340 were the needed as multiples, but no one understood a thing, and management turned it down as totally unmantainable.



The geek then sligtly changed some output parameters of his script and posted it on the Internet, where it became popular as a computer game called "Squash the Bill".



Has anyone  seen it recently? Could you post the source code here?
#43
newLISP newS / marginally more convoluted
December 23, 2008, 10:10:50 PM
1. you know what? I have just made it marginally more convoluted, like this:
Code Select
(for (x 1 100 1)

  (or
   (and (set 'three (= 0 (% x 3))) (println "Fizz"))
   (and (= 0 (% x 5)) (or
      (and three (println "FizzBuzz"))
      (println "Buzz")  ))
   (println x)
  )

)
(exit)

Piece'o'cake ;)))))))))





2. .. but the true corporate solution would be this:


Code Select
(println 1)
(println 2)
(println "Fizz")
(println 4)
(println "Buzz")
(println "Fizz")
(println 7)

Note to the team leader: "please forward this code to the junior member of the team to complete typing"



Note to the manager: "I have submited perfectly working code which should meet all deadlines. The team will be working on the next version as time permits to improve satisfaction in case of customer requests for number of items other than one hundred"





3. But by the time work on the second version started, it was mandated that all code followed the Object Oriented Paradigm.

So, in accordance with the principle that objects reflect real life entities, the program now generates 100 "Child_player" objects, which are passed request_messages from the Game_Master object (the supervisor pattern?). Each of the objects' reply to the Fizz-Buzz question is then collected and formatted centrally for dispatch to the expernal requesting entity.



..mmm working on it.





4. Just got an e-mail from the management. Version 3 is supposed to be a network distributed  solution. Each of the 100 children objects will be converted to a freely-flying persistent network agent, which maintain their internal state and are able to change their chairs so to say, while still engaged in the game. Results are to be sent to a company overseas branch and support integrity checking and strong encryption



Help!
#44
newLISP newS / LMHO
December 23, 2008, 09:52:25 PM
Cormullion - thanks, laughed my head off



However I did not see immediately how to do it in a roundabout and convoluted way while using some intricate functional programming techniques (that's what this challenge was about, right?)



Because otherwise, in procedural and straightforward stle it looks almost indecently naked:


Code Select
(for (x 1 100 1)

 (set 'three (= 0 (% x 3)))
 (set 'five (= 0 (% x 5)))

 (or
  (and three (not five)(println  "Fizz"))
  (and  five (not three) (println "Buzz"))
  (and three five (println "FizzBuzz"))
  (println x)
 )
)
(exit)

So I'm waiting eagerly (not lazily) for improvements of this solution.

Actually, I could write an interesting one if a non-lazy OR (i.e. the one that evaluates ALL its parts in any case) was constructed
#45
newLISP newS /
December 10, 2008, 01:09:57 AM
Here's an example from documentation which looks like a helpful hint to me:


Code Select
(map if '(true nil true nil true) '(1 2 3 4 5) '(6 7 8 9 10))
    --> '(1 7 3 9 5)

From alphabetical section on functions in User Manual
Pages 1 2 3 4 5