Slashdot Mirror

No one questions the validity of it....

relevant paragraph:

"Psychologists from Edinburgh Napier University surveyed 200 students on their use of Facebook, and found that a for a significant number of users the negative effect of the social network outweighed the benefits of staying in touch with friends and family. "

Apparently, if you agree with something there's no need to analyze where did it come from. The conclusions per se are interesting but many are debatable and might vary greatly if we switch the social frame of the users.

TFA didn't even feel necessary to put this:

FURTHER NOTES:

  Informal focus groups were conducted using opportunity sampling of third year psychology and social science students. The three groups comprised seven students.

  The online survey attracted 175 participants of which 127 (72.6%) were female and 48 (27.4%) male. The mean age of the sample was 30.4 years (SD = 10.3, range 18 to 62) with four participants not disclosing their age.

  Five participants (two male) participated in semi-structured interviews on their use of Facebook. They were drawn from a subset of the survey sample who indicated their willingness to be interviewed.

Isn't it possible to argue that students related to the subject might be more prone to over analyzing and over thinking these situations? Or maybe they're more likely to answer truthfully?

Anyway, Too small, too specific sample to end up with arguable conclusions.

All germans, please sign this petition:

http://itc.napier.ac.uk/e-Petition/bundestag/view_ petition.asp?PetitionID=294

It currently has 13748 votes.

Thanks!

It took a guest lecture of a nobel laureate to convince me that there are legitimate uses of color in mathematical formulae on overhead slides. That, and a great lecturer who worked heavily with Mathematica notebooks he modified and evaluated in-class, made me rethink my somewhat fundamentalist attitude to computers in class. The technology is not bad per se, but instead of enhancing the learning experience it's too often used to save time, work or money (in the extreme case replacing teacher time by CBT; I very much agree with Andrew Cumming's CAL rant on this).

In that case, it's your lucky day. Check out these sites:

The Dream Project
Global Grid Forum

Not too sure if it an improvement, but I know some people use languages in which programs can be proven to work like ML. Of course if you actually want to write a program which *does* something it is probably not for you.

At low level, pointers are everything, and low level is what you want to teach when you're teaching basic data structures and algorithms.

Conceptually and from a computer science perspective, the object references present in languages like Python, Java etc. are equivalent to pointers in all the ways that matter for representation of data structures and algorithms. In the academic community and elsewhere, it's generally considered beneficial to teach such things without reference to the machine pointers which you're referring to, since machine pointers carry a lot of baggage that's unrelated to the abstractions involved in data structures and algorithms.

There's simply no point in demonstrating list implementation with an interpreted language that has very efficient native lists, dictionaries, etc.

To refute this, let me offer a tutorial: A Gentle Introduction to ML. If you work through this tutorial, you'll very soon begin implementing functions in the ML language for basic list operations and the like - functions that already exist in the language. And guess what: the implementations that the beginner typically comes up with in that tutorial are very close to the actual implementations that ML uses - the tutorial gives some examples of actual implementations for comparison.

This high-level operation doesn't even cost much -languages in the ML family, including OCaml, regularly are top performers - see e.g. Doug Bagley's language shootout. They can perform on par with languages like C because their type systems allow sophisticated compile-time optimizations to be performed, and their high-level abstraction features are supported by optimizations such as tail recursion.

C/C++ or Pascal are much better for that; with them you can teach real implementations, not toy ones.

If you believe that C/C++ and Pascal are good languages for teaching computer science, you don't know much about modern computer science. All three of those languages have very weak type systems and lack basic features that allow the construction of high-level abstractions.

Pascal is all but a dead language in the CS community nowadays. The primary use for C is as a decent portable assembler. Learning C has very little to do with computer science, and absolutely nothing to do with teaching computer science concepts.

Sounds like you didn't actually learn the lesson. Recursion and loops are mathematically equivalent - if you see a difference between the two, it's only in your head (and perhaps on the stack of a language that doesn't properly support it).

All of the most sophisticated languages available today make recursion a very natural part of their operation: the ML family, including OCaml; Haskell; and of course, Scheme. Here's a factorial function in ML:

fun fact 0 = 1 |
fact n = n * fact(n-1);

If you'd like to learn about recursion in a very natural way, try A Gentle Introduction to ML, which is an excellent tutorial. You don't have to get very far into it before it becomes obvious how useful and natural recursion can be.

• http://forwardslashunix.com/history.jpg
• http://www.ic.ucsb.edu/~lopaka/images/unixhistory. gif
• http://www.dcs.napier.ac.uk/~rcr/cs71011/Unix-hist ory.JPG
• And the BEST one: http://perso.wanadoo.fr/levenez/unix/history.html

The curious thing is that despite GAs being widely researched for over 20 years, they seem to have found few practical applications that I am aware of.

Actually, there are quite a few applications of evolutionary computing. A good reference of research results can be found at Bbase. A researcher at the Lappeenranta University of Technology maintains a comprehensible link list about evolutionary algorithms, which also features link to Evoweb, which has quite nice list of applications in several different areas ranging from music generation to financial forecasting.

The curious thing is that despite GAs being widely researched for over 20 years, they seem to have found few practical applications that I am aware of.

Actually, there are quite a few applications of evolutionary computing. A good reference of research results can be found at Bbase. A researcher at the Lappeenranta University of Technology maintains a comprehensible link list about evolutionary algorithms, which also features link to Evoweb, which has quite nice list of applications in several different areas ranging from music generation to financial forecasting.

But ML turned out to be great! It functions like Lisp, but has some additional interesting features:

• Strong type checking: Most of my Lisp errors were type errors. ML is the most strongly typed language I have heard of (its often used by language theoriticians). When you run the program it is first fully type checked, very few runtime errors are even possible. What makes it different from C is that type checking is implicit (although you can specify types if you want). The compiler/interpreter will figure out which types a function can accept, so you can have a function that accepts many different types for some argument, yet you get the safety of full type checking.
• Its simpler than Lisp. Lisp has too much crap thrown in. ML is more understandable (like Scheme).
• Few parenthesis. Although your programs are structured similar to Lisp, most parenthesis are not needed, which IMO really helps readability and makes it easier to change (no more counting parenthesis when you add something).
• More powerful functions. When you call a function the arguements are actually matched against a pattern in the function declaration. The function with that name which has a pattern that matches the closest is used. You can write interesting recursive functions where one version of the function gets called normally, and another gets called when the argument is a 1, for example. This only scratches the surface of how powerful this feature is.
• There is even an object oriented version: Caml

Only the cones are receptive to color. The rods are only receptive to brightness and dimness.

Correct. This was a copy-paste error of mine. The specifics are outlines on this page, in the "PHOTOPIGMENTS" section.

Karma karma karma karma karmeleon: it comes and goes, it comes and goes.

unlike a CRT's phosphors, our retinas do not have separate 'pixels' for red, green, and blue

Actually, we do. I dont remember the details, but some of our retina's cones and rods capture only specific colors. Color blind or people are people with disorders of such specific cones and rods, when it's not due to brain issues.

I'm partly color blind, as I have difficulty seeing yellow.

When our retina differs from CRTs, however, is resolution, of course.

One good place I found for info on this is this place, and for info specif to color vision, this sub-section is handy.

Karma karma karma karma karmeleon: it comes and goes, it comes and goes.

unlike a CRT's phosphors, our retinas do not have separate 'pixels' for red, green, and blue

Actually, we do. I dont remember the details, but some of our retina's cones and rods capture only specific colors. Color blind or people are people with disorders of such specific cones and rods, when it's not due to brain issues.

I'm partly color blind, as I have difficulty seeing yellow.

When our retina differs from CRTs, however, is resolution, of course.

One good place I found for info on this is this place, and for info specif to color vision, this sub-section is handy.

Karma karma karma karma karmeleon: it comes and goes, it comes and goes.

So along come some doods who said why don't we recursively stick the particles into boxes and then calculate the attraction between the boxes instead and it should be a lot faster. So they tried it and it seemed to work great- it only takes more like 10,000 calculations to do 1000 particles.

Anyway along came some other guys and they were a bit suspicious. They showed that some galaxies fell apart under some conditions with the recursive boxes method, when like they shouldn't. Back to the drawing board.

There are some fixes for this now- they run more slowly, but still a lot faster than the boring way. Still, its better than the end of the universe. Even if it is only a toy universe.

For descriptions of loadsa algorithms, including 'symplectics' which are able to predict the future of the solar system to 1 part in 10^13 ten million years in the future check out this link: