Slashdot Mirror

You noted but didn't bother to post any evidence supporting your claims. We can wait.

Fair enough.

First, a thought experiment: Imagine Acme company sells widgets at 10 dollars each. One hundred people buy the widgets. Another hundred would like them, but cannot afford them. Uncle Phil sees this. Uncle Phil is a multi-billionaire. Uncle Phil says to those who cannot afford them, "I'll buy you your widgets for you." So now you have two hundred people buying widgets. The business sees its demand going up, and thus begins increasing prices. Most of the original hundred keep paying. Phil is a multi-billionaire so price isn't an option. The business owner wants maximum revenue, which is the maximum (price x quantity). So, business keeps jacking up costs until he reaches that point. If the widgets are essential to life (i.e. have inelastic demand), the original hundred do everything they can to keep paying the higher price.

So - that's the thought experiment.

Here's a paper by a Nobel (equivalent) laureate in economics, the conclusion of which states that subsidies will drive up prices in monopolistic environments (see page 28, the first paragraph of the section titled 'Conclusion': "This paper demonstrates two ways that a subsidy may increase equilibrium prices in a monopolistically competitive market"). My addition is that they drive up prices when demand is inelastic as well: Paper by Joseph Stiglitz (PDF).

You know who else wrote a cogent article on this? The Duke adult film actress, "Belle Knox." She talks about the impact of government subsidies in education, which isn't a monopoly, but for which demand is inelastic.

Post-web people may like to read what was all the rage in the early 1990's: the deep philosophy of software development. Doug Lea has a concise summary, so you don't have to read several hundred pages. And here's a quick direct quote from Christopher Alexander I just now Googled:

...it is not possible to make something beautiful, merely by combining fixed components.

I presume the 9 lines in question refer to TimSort.rangeCheck().

Have you ever looked at it? If I had to implement that method, I probably would have done it the exact same way.

I seem to remember the Java thread pool libraries came from the State University of New York at Oswego; now I see that were written by prog. Doug Lea and it looks like they have been absorbed into the Java standard library (java.util.concurrent).

Take a look. Otswego State University of New York.

Granted, it's only become an OSU recently, but then again Oregon State has only been an OSU since 1961, before which it was Agricultural College of the State of Oregon. Ohio State started life as Ohio A&M, but was an OSU by 1878. Likewise Oklahoma State started as Oklahoma A&M and only became an OSU in 1957.

So either Ohio State is the oldest OSU, or Otswego State is an older OSU than Oregon State.

Damn. I don't even use Java(I'm an embedded C guy), but if DL did it, then it's probably really good. As a C developer I feel the old pthreads style is a throwback to old multi-process hacks on SysV of 25 years ago.

What dragged you to the dark side anyways? (C#/.NET)

The Oswego library was the bomb. It's basically how APIs should be designed: Very simple looking abstract interfaces* with a bunch of reference implementations, some of which are incredibly advanced. You can then pick and choose what you want, reimplement anything at will, and combine like Lego. That guy saved me a LOT of time and bug hunting. Want a queue? Pick from four different flavors! Want priorities? Done! Want to keep the queue but change the execution style or locking mechanism? No problem!

As to switching, I've always generally been a Windows guy, and C# is currently the single fastest way to develop a GUI and not get "stuck" too much, because it can call C or COM style APIs directly. When it was first released, a good former Java/C++ developer could get started with it quickly, and develop GUIs 2-3x quicker than anything else, which then ran smoothly, and looked native.

I still get frustrated, especially with the lack of decent containers, algorithms, and threading frameworks, but C# is still overall the best. I do a lot of very Windows platform specific stuff like Active Directory manipulation, and it would be very hard to do that quickly (but correctly) with any other language.

Java is great for "server side" development. It has better database binding** libraries, threading, third-party support, containers and frameworks, and a much better community. However, its client-side is just terrible, especially the GUI frameworks. SUN apparently still hasn't learned the key to Microsoft's success story: own the client, and you will own the world.

It's only recently that Java IDEs got decent "drag & drop" forms development, while Microsoft is already a generation ahead with WPF which very cleanly separates code and layout, to the point that artists can do layout almost completely independently of the dev team. Think of what HTML and CSS tried but failed to do, but done properly.

*) Microsoft has an allergy to interfaces. It's like they're trying to tell you that they "own" the API, and you, the developer, should keep your dirty little mitts off it.

**) Microsoft's LINQ to SQL is practically a beta at this time. They don't even support multi-columns keys! Its big brother, the "Entity Framework" didn't support foreign keys until .NET 4, which is currently beta, and the GUI editor still fails on all but the simplest models. Something like 60% of the features, if used, disable the GUI editor completely. Microsoft isn't even planning to finish the EF framework GUI, ever. Every couple of years, they come up with a new data binding framework, drop the old ones, never finish it, and then they repeat, not having learned a single lesson. I've lost count.. there's been, what: DDE, ODBC, ADO, ADO.NET, LINQ, EF, and now they're up to some garbage called "M" or "Oslo" or whatever. I'm certain it'll be buggy, slow, incomplete, and replaced in short order. Just watch.

Damn. I don't even use Java(I'm an embedded C guy), but if DL did it, then it's probably really good. As a C developer I feel the old pthreads style is a throwback to old multi-process hacks on SysV of 25 years ago.

What dragged you to the dark side anyways? (C#/.NET)

I can't stand it when Microsoft developers talk about multi-threaded programming when the entire corporation has done that absolute bare minimum to make developer's lives easier. No wonder that they don't like using their own tools, because their tools are terrible.

Many years ago, a brilliant third-party multi-threaded library was released for Java, by a professor at Oswego university. I used it in several large production apps, and it absolutely rocked. You could build up safe, reliable, scalable multi-threaded applications by simply snapping together flexible pieces like Lego. It was so good that it became a part of the SUN Java standard library, and it's now called "util.concurrent". Compared to having to "hand craft" multi-threaded code in C++, it was wonderful. It's as if the lights had just turned on, and everything had become clear to me.

Now that I'm a C# dev, it's been a huge step backwards, doubly so because .NET was developed after the Oswego library was already popular, so Microsoft must have seen it and just flat out ignored it. For years afterwards, the whole entirety of multi-threading in both .NET and C++ were "threads" and "locks". The one nicety they included was an anemic thread pool in .NET which was just usable enough for the most basic tasks, but couldn't handle any real load. Even the locks were heavyweight inter-process kernel locks that are unusably slow for many tasks.

It's only now in .NET 4 (which won't be final until 2010) that they are adding a small set of very basic lock-free containers, light-weight locks, and actual interfaces that one can implement in order to customize behavior. It's all still very basic, and nowhere near as flexible, powerful, or comprehensive as the Java APIs that are years old now.

Microsoft's general attitude to API design is so bad that it can only be described as wilful ignorance. Reading articles evangelizing "modern multithreaded programming to better utilize new multi core processors" somehow feels like a religious zealot harping on about their appreciation of pure rational logic and science.

Yes, I did look at some examples. Unfortunately they're all in Objective C, but I got the main ideas, I think. I'm just noting that there isn't anything novel here. There's no big leap in productivity for writing parallel programs. You acknowledge this by referencing Microsoft's implementation.

There's nothing inherently bad about this. I was just hoping I might learn something new.

There's nothing new here in the big scheme of things, in a sense that this approach was known for a long time now, and there were production-quality libraries in existence before. The big deal is that major players - Apple and MS - are now including this as core part of their software development stacks. GCD is in Snow Leopard, PPL (and PLINQ, which is the .NET counterpart) will be in .NET 4.0. If I remember correctly, something similar is brewing up for the next major Java release as well.

In other words, the big news is that this is becoming mainstream.

And this definitely brings a fairly large leap in productivity when you compare it to manual thread-management techniques. Yes, this isn't STM (or something else that's supposed to be the silver bullet when it comes to parallel computing), but it is a move one step higher on the abstraction ladder, and the benefits are noticeable.

Java 7 will have something very similar, called the fork/join framework: http://developers.sun.com/learning/javaoneonline/j1sessn.jsp?sessn=TS-5515&yr=2008&track=javase Doug Lea also offers a preliminary package for Java 6 that can be downloaded from here: http://gee.cs.oswego.edu/dl/concurrency-interest/

If what you want is to design multi-threaded applications (thus, more than just coding multi-threaded apps), then the book you want is: Concurrent Programming in Java

A little on the stuffy side at times (not quite as easy a read as Design Patterns) it still provides a deep understanding of the trade-offs and techniques used when designing multi-threaded applications. Personally, I found myself again and again using the lessons and many of the patterns of that book when designing new systems (or fixing systems designed by people who were not used to multi-threading).

One of the best value for money books I have for Java.

PS: The concepts and lessons, being at a software design level, are easily portable to other languages.

Concurrent Programming in Java is more or less *the* book on good practices for multi-threaded programming for Java, with many lessons that apply to other languages as well.

"Then there is the Collections API itself which upon first glance seems like it was written by amateurs who have never had to write any performance critical code in their lives."

I think the situation has improved since Java 5.0 thanks to Doug Lea.

http://gee.cs.oswego.edu/dl/concurrency-interest/i ndex.html

Yes, some Sun engineers are amateur. But I don't think you can claim that for Doug Lea!

It is true that java 5 added the java.util.concurrent package. However, if you are using 1.4 (or really 1.2+) you can use this package:

http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/ dl/util/concurrent/intro.html

The author Doug Lea is the same guy who wrote the 1.5 java.util.concurrent package. He also wrote the book "Concurrent Programming in Java 2nd ed." which is a must read IMO if you do anything multithreaded in Java.

I don't think that "they didn't think through the right way to do it before dashing in to an implementation and stuffing it into core Java" is a fair characterization at all, when it comes to Java's collections. History indicates otherwise, at least to me. Java 1.0, circa 1995, contained only three collection types - the primitive array type, Vector, and Hashtable. These provided adequate functionality for simple things, but certainly didn't provide full-fledged collection support. It wasn't until late 1998, with the release of 1.2, that the collection interfaces and classes were officially added to the JDK. So what happened in between? There were several independent efforts to provide more powerful collection support. One was a set of public domain classes developed by Doug Lea. (It's described here: http://g.oswego.edu/dl/classes/collections/.)
The other was the Java Generic Library (JGL), which was essentially a port of C++'s STL. Prior to 1.2, JGL was quite popular, but Sun eventually went with a solution derived from Doug Lea's classes, rightfully so, in my opinion. (The old Vector and Hashtable classes had to be kept around for backward compatibility, but they were incorporated into the new framework, by being made to implement List and Map, respectively.)
To me, this history shows that in the case of the collections, Sun certainly didn't dash in to an implementation and stuff it into the JDK. Had they done so, there wouldn't have been that 3 year delay, and we'd have ended up with something much worse than what is there now; and what is there now is not bad at all, IMHO.

Read this book: Concurrent Programming in Java: Design Principles and Patterns by Doug Lea. It's a bit dry, but well worth the read. Even if you're not programming in Java, the concepts, problems, and solutions are similar. Java just offers some abstraction.

Understand the primitives, wait(), notify(), synchronized. Then learn Java 1.5's java.util.concurrent package, so you won't have to use wait/notify yourself in most cases.

Most programmers don't understand the issues that come up with concurrent programming, and if you can learn them, it's yet another way to set yourself apart. They used to teach this in operating systems class, but these days, who knows.

Even better, use Doug Lea's excellent concurrency package, which has been integrated into Java 1.5 but can also be used with older Java versions.

I was not necessarily talking about Firefox, just addressing (hah) a misconception in the parent post: fragmentation is not related to garbage collection. I didn't want to get into a lengthy discussion of virtual addressing, page faults, etc. as well ;)

But you're correct. Thanks to the rise of "smart" binned allocators like dlmalloc, fragmentation is no longer the huge concern that it used to be with (for example) the basic Win32 heap API. Modern allocators are now reasonably smart about reusing best-fit blocks and not leaving tiny holes scattered in your VM pages.

Anyway, fragmentation is certainly not the primary cause of Firefox's high memory use. I am merely pointing out that my original post's parent had a poor conception of how fragmentation could be dealt with in.

The miss penalty times I googled for review site where they'd benchmarked it. If you look, you can probably get more accurate numbers from Intel. For the disk latency, the manufacturer of a disk will generally report some sort of access latency number, but overall, a "fast" 7200 RPM disk has a latency of about 8 ms.

So far as how malloc() works, well, it is open source. But some discussion on malloc design can be found at http://gee.cs.oswego.edu/dl/html/malloc.html. More simple information can be found linked at http://www.cs.utk.edu/~plank/plank/classes/cs360/l ecture_notes.html (again, just a quick google).

Mostly, it comes down to that my area is systems and architecture. My job is to know all those little details about how things interact. This was just a quickie. No guarantees it is right--I'm using other people's numbers, and just my recollection of how malloc() behaves. If this were more serious than /. then I'd dig through Intel's processor manuals for more exact numbers, figure out which (if any) of those latencies can happen in parallel, measure things myself to verify, etc. I'd also write a small program to do a lot of mallocs and frees and see what addresses are returned to verify the locality properties.

If I were really really serious, I'd come up with a benchmark program that allocates and frees memory, of various sizes with various working sets and object lifetimes, and measure the execution time for both Java and C. I'd use something like VTune (http://www.intel.com/cd/software/products/asmo-na /eng/vtune/index.htm) or SimICS (http://www.virtutech.com/) (with a timing model, say GEMS (http://www.cs.wisc.edu/gems/tutorial.html)) to analyze exactly where the differences are coming from.

And then I'd write it up and submit the results to SIGMETRICS, PLDI, OOPSLA, or some other conference, because I just spent a metric butload of time tracing down shortcomings in the GC implementation of various JVMs as compared to programmer managed memory allocation. If somebody is willing to pay me, I still might, but as it is, back of the envelope is all you'll get.

Ah, the devil's always in the details. Environmentalism, diversity and social justice can all be practiced to their extremes. But so can weapon ownership (fully functional Abrams tanks for sale!), capitalism, Jesus-worship, or any other issue near and dear to the right.

So I think it's important to focus on dictionary definitions and see if we're cool with those.

Environmentalism, Wikipedia:
It is a social movement which seeks to influence the political process by lobbying, education and activism in order to protect natural resources. Some of the issues of concern for the environmental movement are pollution, species extinction, waste reduction and genetically engineered foods.
Webster dictionary: advocacy of the preservation or improvement of the natural environment; especially : the movement to control pollution

Ok, pollution kills us, and that's bad, and we should be against that. We shouldn't be mass-killing whole species with what we do... cause chances are, in the long term, it's bad for us too (example: frogs and air/water pollution).
Waste reduction - most people don't want to live on landfills, so yes, that's good. And finally, genetic modification... I'm the most wobbly about that one; on one hand, genetically modified crops feed *so* many people that to go natural would mean starvation for a lot of people. On the other hand, what if those crops get hit by something really bad (like a disease), and since they're all coming from the same gene pool, that might mean really bad mass starvation, all at once. For now, it's good.

Diversity: hard to precisely define. To some, it's meshing incompatible people at the point of gun, to others, it's simply trying to get more people of different opinions/characteristics together. There's no harm in expanding the advertising for your college to some traditionally black/hispanic/other neighbourhoods, is there? There are so many ways to accomplish this, some more and some less voluntary, but I think people should in principle be for exposing their children and themselves to people different than them. Definitely helps the society be more tolerant.

And social justice... ah, a gem of a phrase, and nobody is really sure what the hell it means. Go ahead and type "What does social justice mean?" in Google. Out of the top 6-7 relevant articles, people have some WIIIIDELY varying definitions. Therefore, it's impossible to say whether you're for or against. To some, it's communism and utopianism. Other definitions are more down-to-earth:
http://www.oswego.edu/~prusso1/Russos_what_does_it _mean_to_teach_for_s.htm

What does it mean to teach for social justice?

It means recognizing oppression in its multiple forms, and then taking action in the classroom to interrupt the cycles of oppression. When teachers teach for social justice they are working to end the cycle of oppression.

Hey, we can't be for oppression, can we?

But really, one should never be throwing out just those two words, without saying what they mean by them. So let's park that one then.

So... what do we have? Don't pollute, kill things, or produce a lot of garbage... Do talk to others, and try to learn about them... mingle. And finally, something we all learned in kindergarden: share your toys.

Now I can live with my kids being taught that, can you?

I don't know where you got your understanding of malloc, and especially free, but it's severely out of date. Knuth published about "Boundary Tags" no later than 1973 (citeseer is down, so no link). Saying that a coalesce operation "can be arbirarily slow" is just FUD. A boundary tag makes free() a fast O(1) operation: check the previous block in memory to see if it's free and if so join, a fast O(1) operation; check the next block in memory to see if it's free and if so coalesce; add free block to free-list, done. Yes, it's not zero work like a GC implementation sort-of is, but "arbitrarily slow"? It's basically at least as fast as malloc().

Allocation requests can hit disk, sure, but so can GC allocations even if they're just bumping a pointer: it all depends on the working set size. GC compaction can reduce fragmentation to reduce working set size, but that is only a big win if there's a lot of fragmentation, and most apps using a good malloc() don't exhibit that much. (It is also possible for a GC to rearrange memory so more in-working-set data is on pages together, reducing the working set page count without changing the total memory used. I don't know of any in-use implementations of this, since you need hardware support to know what objects are more-in-use; generally this is only available at the page level, where it's no help. I think maybe an early microde-based Smalltalk implementation might have done this.)

If your malloc has to walk giant free lists to find an open block, then sure, that can be slow. That's why people use trees of free lists based on size and such to make it more O(log N), and O(1) for small allocations. (On large allocations, actually using the memory amortizes the cost.) Read about dlmalloc, for example.

Furthermore, let's not misrepresent GC. Stop-and-collect GCs have obvious extra costs beyond the free-of-charge free (or lack of need for one). Incremental GCs that don't pause are usually slower overall and only preferred for interactive programs. For example, incremental GCs usually require "write barriers" or "read barriers" which require several extra instruction on every fetch from memory or every write of a pointer variable in memory. This can add up across the entire program. Incremental GCs also tend to be conservative, and only end up collecting things that, say, were garbage at the start of the most recent collection round, and generational collectors allow garbage to collect in later generations for some time, so they don't actually necessarily have a smaller working set than a non-leaky malloc()/free() program.

Another big win in non-GC systems is that you can use pointers that don't come off the heap. That way you can avoid allocation and deallocation and GC entirely. (You can actually do some of this in a GC system too if it's a 'conservative' GC that copes with pointers into the middle of blocks. Those pretty much only get used for adding GC to C and C++, though.) Here are some common ways this happens:

• statically allocated arrays
• small arrays and strcts on the stack
• structs that are components of other structs, or arrays at the end of structs
• use of special allocators:
  • slab allocators (it's even possible to embed this entirely inside the default allocator for all small allocations)
  • pool allocators (allocate a large block of memory, suballocate from it, deallocate all at once)
  • "stack" allocators (allocate a large block of memory, suballocate from one end, only allow freeing from the same end, so allocation is a adding to a pointer and deallocation is reseting that pointer)

Of course, doing all these things requires that you balance your different types of malloc()s with the correct, matching type of free(). In practice, GC proponents overestimate the diffi

Doug Lea's Concurrency Utilities - If you haven't yet made the plunge to Java 5.0, this is indispensable for anything thread related.

Trove4J - High performance collections that work with primitives. We do wire-speed packet capture and flow analysis with this stuff. 'nuf said.

Mozilla's LDAP SDK when doing LDAP work

The pre-1.5 concurrent threading classes

Command-line argument handler library

Log4J logging.

The util.concurrent package has been very popular among open-source projects, and is known for its strong performance. In many cases, migrating from util.concurrent should be as simple as importing java.util.concurrent.class instead of EDU.oswego.cs.dl.util.concurrent.class .

Of course, one of the improvements made by JSR166 is to genericize all the interfaces and classes, so what uses to be a BlockingQueue is now a type-safe, parameterizable class BlockingQueue<E>.

Not all of the toolkit made it into the 5.0 release in time, and the missing stuff, referred to as jsr166x, which comprises "concurrent sorted maps and sets, as well as concurrent double-ended queues (deques)", is available for use.

Doug also offers a JSR166 maintenance update that fixed a bug in one of the classes.

The util.concurrent package has been very popular among open-source projects, and is known for its strong performance. In many cases, migrating from util.concurrent should be as simple as importing java.util.concurrent.class instead of EDU.oswego.cs.dl.util.concurrent.class .

Of course, one of the improvements made by JSR166 is to genericize all the interfaces and classes, so what uses to be a BlockingQueue is now a type-safe, parameterizable class BlockingQueue<E>.

Not all of the toolkit made it into the 5.0 release in time, and the missing stuff, referred to as jsr166x, which comprises "concurrent sorted maps and sets, as well as concurrent double-ended queues (deques)", is available for use.

Doug also offers a JSR166 maintenance update that fixed a bug in one of the classes.

The util.concurrent package has been very popular among open-source projects, and is known for its strong performance. In many cases, migrating from util.concurrent should be as simple as importing java.util.concurrent.class instead of EDU.oswego.cs.dl.util.concurrent.class .

Of course, one of the improvements made by JSR166 is to genericize all the interfaces and classes, so what uses to be a BlockingQueue is now a type-safe, parameterizable class BlockingQueue<E>.

Not all of the toolkit made it into the 5.0 release in time, and the missing stuff, referred to as jsr166x, which comprises "concurrent sorted maps and sets, as well as concurrent double-ended queues (deques)", is available for use.

Doug also offers a JSR166 maintenance update that fixed a bug in one of the classes.

This is a problem with several people hav anticipated and have come up with some creative work-arounds for.

As shown here , even the most simplistic of number-crunching systems has to have a half-way usable interface, and I don't see how they're going to manage to put a c64 into the limited space of a palm without losing a LOT of functionality.

But Java is a B&D language that no real hacker would prefer ...

probably has something to do with:

I am still mystified at the academic community's love of Java.

Which strikes me as either a misunderstanding or just plain hubris, I'm not quite sure yet. Don't you think some academics like Doug Lea are "tr00 hackers", given the tremendous contributions they've made to both the science & industry (i.e. Doug's concurrency libraries)?

There's a lot to like about Java. It's not the most innovative language in the world, but in many ways, it was innovative enough for the time and purpose: a portable, garbage collected, object oriented language to replace the dominant lanugage at the time, C++, which was/is a mess.

If you make it a real link Slashdot won't insert the space.

Thanks a lot Sun for posting absolutely no information about the progress of this JSR. At least Doug Lea has posted a little information.

Goatse Revealed
I remember the first time I was linked to Goatse. Yes even I was once like
you. ... Either way, I got my first hit of Goatse. Damn did it hit me. ...
www.dangerz.net/gatasa/article.shtml - 8k - Cached - Similar pages

kuro5hin.org || User Info
... We need your support: buy an ad | premium membership. User info for
goatse. View comments posted by goatse View goatse's diary View ...
www.kuro5hin.org/user/uid:24154 - 17k - Cached

Goatse Merchandise | Powered byCafePress.com
... ordering information | shipping & returns | payment options | satisfaction
guarantee, Goatse Merchandise, ... THE source for all your Goatse needs! ...
www.cafeshops.com/cp/store.aspx?s=goatsemerch - 15k - Cached - Similar pages

The Prime Number Shitting Goatse.cx Man Has Moved!
The link to the Prime Number Shitting Goatse.cx Man is outdated.
Please replace it with the code below. Inform the webmaster of ...
www.oswego.edu/~jpeck/prime/ - 2k - Dec. 11, 2002 - Cached - Similar pages

Bob Goatse interview
Bob Goatse - the passage of the century. ... FC-uk: Hello? Hello? Mr Goatse? Bob Goatse:
(muffled) Where's the cellphone? I thought I heard it. FC-uk: Hello? ...
www.fc-uk.org.uk/goatse/ - 15k - Cached - Similar pages

Project info for Goatse
Project info for Goatse. Page created 5 Sep 2000 by TheGiver (Journeyer), last
modified 5 Sep 2000 by TheGiver (Journeyer). Homepage: http://goatse.cx. ...
www.advogato.org/proj/Goatse/ - 2k - Dec. 11, 2002 - Cached - Similar pages

Goatse
Goatse. ... However I had heard too many people talk about goatse.cx that
have never even seen the full photo gallery of the goatse guy. ...
www.hektik.org/various/various/goatse/ - 9k - Cached - Similar pages

DIRK [goatse.cx]
From to. goatse.cx is connected to because. Warning: mysql_fetch_array():
supplied argument is not a valid MySQL result resource in

Here is a FAQ.

Patterns are named solutions to problems, which resolve constraints in a a given context. They aren't rigid (like, say, a template), they are abstractions of commonly occuring problems and solutions that occur in programming. For instance, "one object needs to do something to another group of objects" might be a problem, and the Visitor pattern might help you find the solution. The code you use to implement the pattern might be radically different than the code someone else uses, but underneath the pattern is the same.

They come from Christopher Alexander's work in architecture, where he saw the same recurring patterns in architecture and felt that they arose from deeper truths about people and societies. An example of Alexander's architectural patterns: "Intimacy Gradient", which is a pattern that describes how the front of a home is less personal and intimate than the back of a home. For instance you might leave your stuff laying out in a back room, but you keep the front room neat for guests.

Very interesting from a philosophical point of view as well, and helps you to better understand why some programs/houses/objects are pleasant to work with, and others are a chore.

O'Reilly Open Books Project
Bruce Eckel's "Thinking in..." books
Data Structures and Algorithms books
MIT's Structure and Interpretation of Programming Languages
Numerical Recipes series
Handbook of Applied Cryptography
The Art of Assembly Language Programming
Object-Oriented System Development
GTK+/Gnome Application Development
GNU Autoconf, Automake, and Libtool
Effective Perl (partial)
Programming Pearls (partial)

I was searching the internet the other day and came across a few articles of interest.
For one, I found an article about how researchers over at Oswego State University (of New York)
found the largest prime number to date! Incredible!

As I continued on I went over to Amazon and found this book. It's mainly about how you can encrypt every email you send using Java. I didn't
believe it at first so I stopped over at java.sun.com to check it out and found this article in
their "press release" section which seems to confirm this.
Not bad, but that wasn't the only information I found today.

I was over at Yahoo News and learned about how HP's newest line of calculators
will be able to run linux. Again, this is hard to beleive so I checked it out and found it was true over.
The link they had on HP's website was dead so I went over to Google and found it cached here.

All in all - it's a good time to live!

Math is good. This site has all kinds of math stuff, mainly prime numbers and such.

Enjoy!

It's way slashdotted - so I had my friend mirror it to his school account.

Not to burst the slashdot bubble about weblogging, but if you want to try a really nice weblog, try GreyMatter from www.noahgrey.com.

It's great CGI software!

Check out my weblog (Yes, blatant plug) @ www.oswego.edu/~scooper3/journal/index.html

Pretty easy. Got it on my second try.

It kinda helps to happen to know that the very last word in the scrabble player's dictionary is zyzzyva (requiring the only Z, both Y's, both BLANK's, and half of the V's. 75 points with the seven tile bonus LOL). I even remember that zyzzyva is a tropical weevil, hehe.

My immediate reaction for a second word was aardvark, but bad choice. Several occurrences of "from aardvark to zyzzyva".

For my second try I went with meteorology which returned 2 matches (plus 1 redundant match not displayed). The first match was this evil page. (WARNING - 9.1 MEG TEXT DATAFILE)

Then I found zyzzyva herpetology which returns no matches. Herpetology: study of reptiles and amphibians.

P.S.
People just can't resist challenging you when you put a word vertically simultaneously creating 4 or 5 two letter words horizontally, and announce that "oe" is a whirlwind off the Faeroe islands :)

Y,IAAG. (Yes, I am a geek) I created a list of all (96) legal 2 letter words. I haven't memorized them all though. Perhaps because no one seems to want to play scrabble with me :)

-

check this out

your hard hearned tax dollars at work?!

Dude, here's something that will cure what ail's 'ya.

Cheers!

I feel that being able to multithread code effectively in Java would make a programmer advanced in that topic.

Here's the best book on the subject:

Doug Lea, Concurrent Programming in Java. Second Edition: Design Principles and Patterns


book home page

author home page (pointer to online supplement for the book)

at Fatbrain

at Amazon

I feel that being able to multithread code effectively in Java would make a programmer advanced in that topic.

Here's the best book on the subject:

Doug Lea, Concurrent Programming in Java. Second Edition: Design Principles and Patterns


book home page

author home page (pointer to online supplement for the book)

at Fatbrain

at Amazon

Doug Lea (well known C++ programmer and writer; teaches at SUNY/Oswego)

Kevin Sullivan (U. of Virginia)

A couple of less positive articles from Australia.

An article at O'Reilly.

The best-commented code I have ever seen is Doug Lea's malloc, or dlmalloc, the malloc used in glibc, among other places. I had no idea how a malloc would work, and I wanted to write one for my OS class, so we looked at the dlmalloc source code. MAN, that's some well-commented code! Not only does it explain what individual functions do, but it also explains each general part of the algorithm in excellent detail. And it's malloc; it better not have any bugs!

That's pretty simple, huh? (You don't even need the int member -- it's just there for clarity.) Just because Java doesn't provide a syntax for enums doesn't mean it's impossible to implement typesafe constants easily, just like it's possible to write code which uses semaphores instead of monitors as long as you build a semaphore framework yourself (see Doug Lea's page for a lot of useful concurrent Java info).

Adding syntactic sugar to a language merely shackles developers to the way the language designers thought a problem should be solved, and saves a few keystrokes at the cost of lost consistency.

Typesafe value types are not a bad idea (*shudder* Pascal uses them to some advantage), but it is just plain dishonest to say that they provide anything more than sugar in an OO language.

Remember, folks, as Alan Perlis said: "Syntactic sugar causes cancer of the semicolon."


~wog

In fact, I seem to remember a few years back that Doug Lea had figured out that MS had taken his kick-ass memory allocator off the Net and used it in one of their OSes (NT?). Since he didn't have the money or time to fight them, he didn't bother. He eventually dropped the copyright and left it to the public domain.

I know I should prejudge people, but I wouldn't be at all surprised if this sort of thing were all over MS's code.