Slashdot Mirror

I find that British humor really went downhill after Andy Capp stopped smoking and beating his wife.

Andy Capp!

Andy is a working class figure, living in Hartlepool, North-East England. His hobbies include pigeon racing, snooker, football (which always involves fights with the other players, and frequently ends with Andy being sent off), occasionally cricket and rugby, betting on horses, getting drunk (often falling in the canal and, always, seven nights a week, arriving home late as a result), fishing (and not catching anything bigger than a goldfish), womanizing, lying on the sofa and fighting with his long-suffering wife, Flo.

British humor is a somewhat general term applied to certain comedic motifs that are often prevalent in comedic acts originating in the United Kingdom and its current or former colonies. Comedy acts and television programs typical of British humor include Monty Python, Benny Hill, and Keeping Up Appearances to name a few that have become quite popular outside of the United Kingdom. At times, however, such humor can seem puzzling to non-British speakers of English (references to English slang terms or people, who are unknown internationally for example) while certain Commonwealth nations (such as Australia, Canada and South Africa) tend to find it more familiar. Many UK comedy TV shows typical of British humor have been internationally popular, and have been a strong avenue for the export and representation of British culture to an international audience.

Did you miss the part where I said "including being colonized"?

I don't doubt the Sami are people, but are they a distinct nation?

The Sami, in some places spelled "sammi" though with other variations of spelling, I wouldn't say are so much a distict nation as much as they are part of a group of interrelated peoples. They are related to the Lapps which is a derogitory term, Lapps call themselves Samek or Sambe, and range from northwestern Russia to Norway and Sweden. Also related are the Inuit of Iceland and northern Canada and Alaska. Because these people are spread over a broad area they have formed their own dialects and customs. Here's a link to a pdf on Artic languages from UNESCO, Artic Languages: An Awakening. It's quite large at 446 pages and more than 2MB. Here are more links:

• An introduction to the Sami people
• The Sami in Finland
• The Sami and Lapland
• The Kola Sami in Russia
• INUIT CIRCUMPOLAR CONFERENCE
• Eskimo (Yupik/Inupiat/Inuit)

I find it rather humorous that these people are appealing to the authority of a Franciscan monk to try to disprove Christ's resurrection.

Brother William of Occam's biography.

.NET, Java and many other garbage collectors use a "mark and sweep" technique (see Richard Jones's site for a discussion of GC algorithms). A closed loop of objects without other references into the circle is recognised as unreachable and therefore garbage collected.

An unneeded object will be GC'd even when part of an unneeded circle. If the object has a finalizer, it will be run.

Even if there is no need for a GC pass to reclaim memory, finalizers are run when an app is shut down.

You can find a description here.

The only difference is that this module was intended to make undergrads see the failure and risk by means of software engineering, and we did this by looking at various procedures for writing secure code, and we looked at lots of examples from history (the challenger incident, for example, etc).

This course seems to be aimed more at specific coding practices - avoiding buffer overruns for example. It doesnt look like they'll be told how to deal with failure once it happens (because it *will* happen). I also fear that since Microsoft will be involved, it'll be specific to Windows & x86 -- not a real life view of computing.

You need to handle pointers and references, google for pointer swizzling. Garbage Collection by Richard Jones and Rafael D. Lins explains some of the issues involved. Alexei Andresceu's Modern C++ Design gives a sample implementation. This is one of the tasks that reflection, aspect-oriented programming or a meta object protocol makes easier, otherwise you need to add a .serialize() method to each object.

It depends on the thread abstractions that are used for synchronisation and thread communication. The most commonly used abstractions today (semaphores, locks, etc) date from the 1970s; there are much better ways to do it!

One way derives from a mathematical notation created by Tony Hoare, called CSP. There is one unit of thread communications and synchronisation, called a channel. It's like a rendezvous point that allows a value to be passed between threads. If one thread tries to send a value on a channel, it will block until another thread tries to read from the channel (also, reading from the channel will block until another thread tries to send on it).

This scheme is incredibly versatile, easy to use and cheap. There are also some tools that can aid in automatic verification of software built in this way. It's true that it's possible to deadlock in concurrent systems, but it's almost always possible to structure the system in such a way that it's deadlock-free by construction. For instance, if my program is structured as a one-way pipeline, it's impossible to deadlock.

Concurrency at this level in a GUI application can greatly enhance the simplicity and maintainability of a program. This is because it's generally much easier to write a straightforward piece of imperative code than encode the same thing as a state machine, e.g.

while (buttons != 0) {
(buttons, point) = <-mouse;
drawat(point)
}


(where <- receives from a channel), versus:


callback(buttons, point) {
if (state == DRAGGING) {
if (buttons != 0)
drawat(point);
else
state = NOTDRAGGING;
}
}

You say:
That would be the case if interaction was a parallel activity, but unfortunately it's not.

But it is! Yes, the user themselves only contributes one thread to the activity, but the program itself is often dealing with multiple activities at the same time; for instance updating itself in response to network activities or updating graphics on a time-step basis.

The most important thing it gives you, in my experience, is the sense of control. As a separate thread, you are free to structure your application in a way directly appropriate to the task being solved. In a callback system, you are at the mercy of the caller; you can't just wait for an event, then do the next thing, you have to encode your current state, return, and wait to be called back, whereupon you have to figure out where you just were!

For a language that exemplifies this, see Limbo, the language of choice in the Inferno environment. No problems with thread unsafe graphics there!

• Why Functional Programming Matters
• Haskell: The Craft of Functional Programming Second Edition
• FAD: A Functional Analysis and Design Methodology
• Structure and Interpretation of Computer Programs
• Concepts, Techniques, and Models of Computer Programming
• CLOS Meta Object Protocol

So, still keeping some Java projects, I've decided to try something else. First I've tried was Python, which I used for while in OS automation scripts, but now I've tried to use it for a bigger scope: "servlets", UI, JMS-like messaging, XSLT, text processing, RDF, and finally in some AI stuff using FP, which is poor in Python, but at least it is there. By the way, OOP in Python is also far away from being perfect. It is slow on massive calculations, although it is fast enough for script -based OS automation, UI, "servlets" and XML processing (but not on huge files). it is dynamically typed and it has lazy evaluation - both very important features for messaging. Python is less known, comparing to Java, but its community is not really tiny as Perl and other *n*x hackers usually know Python.

After Python I've tried Erlang, Oz, OCaml, Haskell. I think Erlnag is ready for distributed messaging and for OS automation. The others are not - the lack of libraries. Although, each of them, Oz, OCaml and Haskell, has a very great potential if some big corp will do support. Any of these three may need just 10% of Java marketing to collect a crical mass and become recognized.

Before Java I had an experience also in C, Perl, Scheme, Lisp and Tcl, in few projects each. C is very "crashy" in you hands if you don't use it every day. Tcl does not handle well big enough apps. Perl is a "write-only" self-obfuscated lang. The only choice left is Lisp and Scheme. Lisp is very power for big standalone apps, Scheme is convinient for being embedded somewhere.

So, in the finals I've got Python, Erlang, Scheme and Lisp. Not a bad choice.

Coming back to UML. It does same help for Python programming as for Java. As for Lisp/Scheme and Erlang, I think that things like UML are too primitive to fit. On serious languages you need a serious math, and usually diagram is just an iluustration in the math article, not a whole article.

So, if you tired from kid pictures get the math in your hands :)

• Why Functional Programming Matters
• Haskell: The Craft of Functional Programming Second Edition
• FAD: A Functional Analysis and Design Methodology
• Structure and Interpretation of Computer Programs
• Concepts, Techniques, and Models of Computer Programming
• CLOS Meta Object Protocol

So, still keeping some Java projects, I've decided to try something else. First I've tried was Python, which I used for while in OS automation scripts, but now I've tried to use it for a bigger scope: "servlets", UI, JMS-like messaging, XSLT, text processing, RDF, and finally in some AI stuff using FP, which is poor in Python, but at least it is there. By the way, OOP in Python is also far away from being perfect. It is slow on massive calculations, although it is fast enough for script -based OS automation, UI, "servlets" and XML processing (but not on huge files). it is dynamically typed and it has lazy evaluation - both very important features for messaging. Python is less known, comparing to Java, but its community is not really tiny as Perl and other *n*x hackers usually know Python.

After Python I've tried Erlang, Oz, OCaml, Haskell. I think Erlnag is ready for distributed messaging and for OS automation. The others are not - the lack of libraries. Although, each of them, Oz, OCaml and Haskell, has a very great potential if some big corp will do support. Any of these three may need just 10% of Java marketing to collect a crical mass and become recognized.

Before Java I had an experience also in C, Perl, Scheme, Lisp and Tcl, in few projects each. C is very "crashy" in you hands if you don't use it every day. Tcl does not handle well big enough apps. Perl is a "write-only" self-obfuscated lang. The only choice left is Lisp and Scheme. Lisp is very power for big standalone apps, Scheme is convinient for being embedded somewhere.

So, in the finals I've got Python, Erlang, Scheme and Lisp. Not a bad choice.

Coming back to UML. It does same help for Python programming as for Java. As for Lisp/Scheme and Erlang, I think that things like UML are too primitive to fit. On serious languages you need a serious math, and usually diagram is just an iluustration in the math article, not a whole article.

So, if you tired from kid pictures get the math in your hands :)

Borland might use Java to write JBuilder, but did they use RUP or Rational Rose? I don't think so.

I heard from the teacher on courses of Rational University that Rational uses neither RUP nor Rational Rose to create their software.

After a couple of year of my own experience I am very careful with RUP - it does not fit every project. OOP either. If you feel the same - try FAD: A Functional Analysis and Design Methodology.

On the subject of conference presentations, I was browsing the University of Kent's website when I found this excellent article in their Psychology section, entitled the Do's and Don'ts for Conference Presentors.
This might be of interest to the other slashdotters, because though it's a 1998 article, it deal with the psychological impact of Conference presentations, which do not change with year-to-year revisions of the Powerpoint series and the like.
/quit
Megumi

On the subject of conference presentations, I was browsing the University of Kent's website when I found this excellent article in their Psychology section, entitled the Do's and Don'ts for Conference Presentors.
This might be of interest to the other slashdotters, because though it's a 1998 article, it deal with the psychological impact of Conference presentations, which do not change with year-to-year revisions of the Powerpoint series and the like.
/quit
Megumi

Well...the Dragon book for starters, as mentioned earlier. That's probably the ur-source for most of the theory behind the magic. Makes my head hurt, though.

Terence Parr's book, Practical Computer Language Recognition and Translation (out of print). His doctoral dissertation is a useful thing too (try the Purdue University library).

comp.compilers is another useful resource. It's archived at http://compilers.iecc.com.

Alan Holub's Compiler Design in C is a classic.

The ACM's SIGPLAN ("Special Interest Group On Programming Languages") and it's journal SIGPLAN Notices of the ACM are all fine resources. So is ACM Transactions on Programming Languages and Systems.

Don't forget the IEEE as well.

Not to mention Abelman and Sussman: Structure and Interpretation of Computer Programs.

The garbage collection page is a good source for information on memory management and garbage collection.

Your university's library is another good resource.

Well. That should keep you out of trouble.

Parallelism primitives? Why not include something like JCSP in the basic Java specification?

It's great being able to define Processes + Channels instead of dicking around with all that synchronized wait silliness. Thanks heaps to Prof. Peter Welch and his team for their work.

Also, apparently there is another CSP implementation for Java called or CTJ, haven't used it, however...

Or is she trying to deliberately give a shoddy analogy in the hopes it gets by people?

Ding! I'll bet 10 to 1 odds that you've hit the nail on the head. That's PR for you! Contrary to the geek ethic where one attempts to be as correct as possible in whatever one says (even if it pisses people off), Hillary and every other spokespuppet use speech as a real rhetorician would, to persuade people that whatever cause they're backing is 'right'.

That's something really useful that should be taught in school: the skill of identifying flawed reasoning and propagandistic logic.

In fact the American Institute of Propaganda Analysis attempted to do just that in 1937 when the Nazis' PR department was churning the stuff out and innocent US minds needed to be protected. Now that the Pentagon is the world leader in 'public relations', it's a lot more convenient for Americans to believe whatever they're told.

Do I sound cynical? :-) Check out the University of Kent's Centre for the Study of Propaganda

We have a small database (26 thousand records), requires very fast reads, little is ever added or changed. It provides the journal listings from this page (see the alphabetic listing). It does not require transactions. It is currently an Access database on a NT/IIS4 server.

The staff who edit it want to use Access. In my opinion, Access is a good DB client. It allows "average" users, who are advanced in the wonders of office apps, to edit and maintain the database, and use the find/replace and cut/paste commands they are used to. I can not see any obvious alternative for a client that works under windows and offers the same functionality.

You will note that the listings on the above page are created by an asp script. The whole web server is on NT. I'm not Microsoft bashing, though this has created a lot of problems. The asp stuff itself just dies (the mtx process goes mad and needs killing). We've spent days looking in to this with no luck.

We wanted to convert the DB to mySQL (easy, done in a couple of hours), use myODBC and let the staff use Access which uses the myODBC driver. We also re-wrote the asp scripts to php (being stupidly simple in what they do, this took a couple of hours). We would then be free to move our webpages to a nice Solaris box (which is still sitting there doing nothing), apache, php, mySQL, etc.

Not for love or money could we get the myODBC stuff to work with Access. We could connect to the database using a free (and very simple) client that is on the mySQL website, so the myODBC connection was working, though not with Access. The mySQL site does give some hints on using Access, but these did not help us.

I'm sure there must be many people in the same situation, i.e. they have a DB used just for some webpages though the staff (not techies, though they do know how to get the most out of office apps) who maintain that information want to use Access (for good reason, it is quite good for maintaining data), but the web server is on a UNIX platform.

We have had to put the project on hold while we work out a solution that does not involve any functionality loss for the staff who use Access.

Indeed. I was one of the lucky ones to get a terminal port in my room when I was at University (UKC), and I connected up my Amiga. They were quite happy for me to do that, but they wouldn't support it. Of course, that was in days gone by, and the Amiga was effectively being used as a dumb terminal, eventually connected to the LAN via some proprietary hardware. I don't know if they'd allow a direct TCP/IP connection to their LAN (which these days is much bigger).

Reference counting is NOT the same as garbage collection.

WRONG! Reference counting is indeed one way of collecting garbage. The fact that it can not handle circular data structures doesn't mean that it's no longer a garbage collector, it's just one of its disadventages. Other garbage collection algorithms have disadventages as well, e.g. Mark Sweep sufferes the start-stop behavior, Copying requires a heap twice the size of what the program needs, etc. No algorithm is more of a garbage collector than the other.

Read a book on the subject and you'll get the idea, I can recommend Garbage Collection - Algorithms for Automatic Dynamic Memory Management.

I was not belittling you. I belittled the your love for Lisp. There are many like you, who get introduced to Lisp, as THE functional programming language... I wish more schools taught modern languages, as opposed to outdated languages (*cough* Prolog *cough*).

Automatic currying of functions reduces the amount of parens needed, when using functions of one argument or N arguements. Lisp has a parens fetish that gets a little messy now and then. Its not to not have to use them as much, as Haskell allows.

"Referential transparency" does not exist when there are side effects. Referential transparency allows transparent threading of your application. Think about have your app automatically run on 4 CPUs, without any code rewriting. Referential transparency also allows more simplistic proof of the properties of your code.

Please hook me up with some good resources on advanced Lisp type systems. Last time I checked, standard Lisp had no type system. A horrid weakness.

Universal lazy evaluation means that your data structures and functions are evaluated in a lazy manner. If you do not understand what I mean by that, then there is no way you can truely experience the beauty of modern functional programming. I know that Lisp may have lazy lists, but I know that overall, it has strict evaluation over its functions/data structures. Here is an example:

f x y = x + 10


Lazy evaluation:
] f (sqroot 2349 + 7/346) (sqroot 343568 + 7/346)
~ (sqroot 2349 + 7/346) + 10
~ (48.4867...) + 10
~ "After this point, the remainding expression is returned. If it needs to be evaluated furthur, because a function needs a more reduced form, then it is automatically reduced. However, it will only be reduced furthur, it is needed."

Strict evaluation (like Lisp, but using Haskell syntax):
] f (sqroot 2349 + 7/346) (sqroot 343568 + 7/346)
~ f (48.4867...) (586.1669...)
~ (48.4867...) + 10
~ 58.4867...
Notice how strict evaluation does more work than is needed? Sure, my example is trivial and silly, but there are cases, where it is not as trivial. Lets say I wanted to define functions over a boolean data type:

And True y = y
And False y = False


Lazy example evaluation:
] And (Not False) (And (Not True) (And True False))
~ And True (And (Not True) (And True False))
~ (And (Not True) (And True False))


Strict (ala Lisp):
] And (Not False) (And (Not True) (And True False))
~ And (Not False) (And False (And True False))
~ And (Not False) (And False False)
~ And (Not False) False
~ And True False
~ False

Note how strict evaluation continuously evaluates the second argument of And, even when it is not needed (the first arguement was False). If real life applications, Lazy evaluation allows for greater modularity in application design. Here is a paper, for you to read, if you care to furthur your knowledge of functional programming and the great benefits of lazy eval: Why FP Matters

I am sorry, but you have to learn why Lisp has been outclassed to understand. Its hard to just show people with a few examples. The paper I linked should be a good start. Many of the parts of Lisp that have been outclassed, cannot just be added on to Lisp. They are fundamental changes that would have to take place, to modernize Lisp. It would no longer be Lisp at all.

Also, read this entire book (its good, trust me): Good FP Book

I argue with you because you show potential. I won't even bother to discuss FP with most of the other people on this board. Many of them truely thing that Perl is a really good language. Its not even worth trying to argue with someone that burried.

You're quite right. It was from the UKC toolset, and it was called 'vdiff'. Written by one Mark 'Burt' Wheedon. Google turns up something about it.

The original version was written to a custom windowing library that had implementations for Sunview and X11.

I've only managed to turn up binaries from 1995, though :-(