Linda Rising, in the last PLoP conference, said something along these lines: “A pattern shouldn’t be an Ahah! or Eureka! but something more like an Hmmmm!”. 

The thing is, a pattern is something recurrently seen in the wild, that try to give an answer to a problem by balancing the forces in some particular way. Not an intelligently crafted solution in the author’s basement. A good pattern is one where a domain expert is able to easily recognize the pattern as: “I’ve seen this!”.

Now, if the GOF’s Design Patterns should have been more or less abstract than they are is ultimately irrelevant; the authors observed those patterns in a particular context, and while they may hold outside that context, that can’t be neither guaranteed nor intended by the authors. That’s why patterns typically have a target audience. In the context they wrote the book, putting additional effort into implementation details have probably lead far more people to grasp it, than it would have been otherwise.

Furthermore, as an example, Ralph Johnson, during the last PLoP workshop, suggested that the patterns I wrote could be generalized far beyond Adaptive Object-Models and into a broader OO perspective. However, that would need a completely different context-problem-forces triplet. Now, someone reading my paper could say: you focus too much on AOMs; you should have generalized. Well, it’s true. But the proposed pattern is intertwined in a specific pattern language, which has it’s own context and forces. For that purpose, I may actually have given too little detail, since several comments I received asked for more in that direction!

Alexander’s work is a great example of what I’m trying to say. The Notes on the Synthesis of Form could, and are easily abstracted into several realms far beyond Architecture. Should we state that Alexander coupled himself into unnecessary detail?

I believe the problem may not be in the patterns per-se (nor even in the GoF book, which should be regarded as a germinal work), but in the people using them. Personally, I think too few people know the GoF book, or for that matter, patterns in general. Those who know and apply them blindly, have completely missed the fact that a pattern is NOT a building block! Maybe that’s why GoF entitled their book as Elements of Reusable Object-Oriented Software, and not Design Rules of Good Object Oriented Software.

Richard Feynman once said: “Know how to solve every problem that has been solved.” I believe the study of patterns endure this ideal. They are not engraved laws of the tissue of software. They are a systematization of intrinsic, almost empirical, observed knowledge.

The reason that iron filings placed in a magnetic field exhibit a pattern - have form - is that the field they are in is not homogeneous…

- Christopher Alexander, Notes on the Synthesis of Form

(…) there are two ways of constructing a software design. One way is to make it so simple there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies.

 – Tony Hoare [Turing Award Lecture, 1980]

“But if all newbie programmers learn these new languages, who will manage the billions of lines of C and C++ we currently use in the future, unless it is implied to be completely be rewritten?”

I’ve heard this line of rationale before… Who will manage the billions of lines of assembly now that people use C and C++? Who will program hardware, now that Universities’ degrees only focus on high-level software?

Careful: this kind of thought is presumptuous at best. Don’t get me wrong, this is not a direct critic to the author, but to the concept. Practices and tools *need* to evolve, so we can achieve higher degrees of abstraction. Attempting otherwise only hold back evolution (and may turn us into old-school dinosaurs, who keep mumbling “back in those days, we used two big drums to program; one was called 1, the other 0″).

After all, there will always be people wanting to beat those drums…

a. I am willing to change my opinion. Do you?
b. Do you agree to discuss using some kind of human logic? Or will you invoke the inability of humankind to understand the arguments you’ll point out?
c. Do you understand the difference between proof and evidence?

Three out of four people will fail the first right away. My fingers are enough to count those who passed the triage, potentially leading to a nice, though inconclusive, conversation.

N.B. Also please take into consideration that things like “God loves us all, even Atheists” are as racist as “God loves us all, even black people”. I would go nuts when I hear the later, so I definitely go nuts whenever I hear the former. There.. Now flame me…

The manual for Mental Blocks claims that, for both C64 and IBM, you put the diskette in label-side up.  I thought that had to be a typo, since every single mixed C64/IBM or Apple/IBM diskette I have ever seen is a “flippy” disk where one side is IBM and the other side is C64 or Apple — until I looked at the FAT12 for the disk and saw that tons of sectors in an interleaved pattern were marked as BAD — very strange usage.

Absolutely… beautiful!

Another option is the idea of the net itself becoming sentient, a vast self-modifying array of connections and information storage with limited connections to the outside world (kind of like that glob of grey goo you carry around in your skull).  If that happens then Gibson help us all - remember that the net is made of about 90% spam, 9% porn, and quite a lot of whining blogs.  If that mixture ever becomes self-aware we’re not quite sure what it’ll do, but the odds are against it being anything good.

Simply Hilarious! You can find the full article here.

“We are star stuff which has taken its destiny into its own hands.”

- Carl Sagan in Cosmos

I thought memory leaks were only true in unmanaged code.
Meant for someone else but not for me.
Leaks were out to get me,
That’s the way it seems,
There are pointers haunting all my DIMs.

And then I saw Dispose(),
I’m a believer.
Not a trace,
Of leaks in my memory.
I saw Dispose(),
I’m a believer, 
I couldn’t leave it, 
If I tryed{} catch{}.

I thought GC was more or less a given thing,
The more I new’ed the less I got, Oh Yeah,
What’s the use of collecting,
All you get is lag,
Being OutOfMemory() is too bad.

And then I saw Dispose(),
I’m a believer.
Not a trace,
Of leaks in my memory.
I saw Dispose(),
I’m a believer, 
I couldn’t leave it, 
If I tryed{} catch{}.

Lyrics by me and Hugo Silva Ready yourself for an MP3…

Mas alguém me consegue explicar porque é que ainda não se fez um Wiki para manuais “obrigatórios”? Eu ofereco-me para escrever material para informática. Serei o único ou simplesmente não há interesse por parte do governo português? Até arranjo servidor gratuito se for esse o problema…

I’ve recently been struggling with .net because of Panels not being destroyed. Since I dynamically create these panels, which hook upon several events in the system, the application started to crawl down after a while due to some thousands/millions of events being fired to panels that should no longer exist. When we started testing the code line-by-line, what we’ve found amazed us: a particular Panel couldn’t be destroyed due to having AllowDrop set to True. WTF?

But there it was: set it to false, and the garbage collector happily destroys the object. Set it to true, and Dispose() is never called, the Panel lives, and the application stalls.

We thought: a bug in .NET? Does this happens in 3.x as well? Yes, it does. But, how is it possible? No one ever found it? After all, Drag’N'Drop is a common feature. Well, apparently, one guy did. But, either I’m misunderstanding the solution, or there is no solution at all.

Help?

I’m currently reading Cocoa Programming for Mac OS X. I’m becoming astonished by the underlying technology in Cocoa. There are some drawbacks, it’s true: for instance, Objective-C is much less intuitive than Java or C#, the whole .h files seem pretty much deprecated nowadays, and there’s definitely a learning curve there. But having a book like this can help a lot in the process.

I’ve just finished chapter 11 from 35 in total. I must say that by now, CoreData amazed me by allowing to create an application to display, manage and persist (with an Undo/Redo mechanism and all) a simple Information System to catalog Books (along-side with an Image, rating, etc…) without a single line of code. What amazes me most, is that there’s barely code-generation going under the hood: it’s the whole pervasive MVC architecture in Cocoa that allows you to bind hotspots everywhere.

I strongly advise every programmer who can to read this book and do the exercises up to the eleventh chapter. If after this point you aren’t convinced, you can flame me at will

My whole dilemma now is: I’m a developer for Windows (it sucks, but that’s what the company I work for do). I can see the potential in this framework, business-wise, but I can’t seem to find a way to bring this into the Windows world. Any ideas out there?

What most don’t know is the exquisite meaning of NP. An NP class problem is one such that a non-deterministic computer can solve it in polynomial time. Got it? Let me express it in other words: A problem which is NP can be efficiently solved by just getting luck in every choice you have to make. For example, in the traveling salesman problem, one can in fact solve it in linear time by correctly guessing the next city. The problem is guessing it right!

Some people have also heard about NP-complete (NPC) problems. What is the difference between a NP and an NPC problem? To put it simple, an NPC problem is an NP problem that has been shown to exhibit the characteristic of being able to be “translated” into any other NPC problem. This means that a polynomial solution found to a particular NPC problem can be easily applied to every other one. It’s like a dictionary of problems; find the solution of a puzzle, and you’ve found the generic solution of that class of puzzles!

And this is where everyone stands… No one have been able to prove that there exists NP problems that can or cannot be solved in polynomial time, since no one ever found a P solution to an NP problem. Of course P = NP could be proved or disproved without actually founding a particular solution: this would mean that every NP problem have an efficient solution, though it hasn’t been found yet.

Keith describes this enigma in such an enthusiastic way that lead me to read the formal problem statement. I must say that even my recently acquired knowledge on formal language semantics is not enough to read it easily. But I couldn’t resist inciting my colleagues and readers to have a glance at it… Enjoy!

P.S.: My apologies to my purist friends from any inaccuracy I’ve made for the sake of simplicity. You are free to flame me in the comments section