voidpointer

If you are modeling in text (which is a good thing) why not use something like alloy (http://alloy.mit.edu/) which is far more expressive and can be analyzed and checked automatically.

Why exactly wouldn't it scale? The challenge is to make sure other stores are run in the same dedicated fashion and not by some dimwit that only hires other dimwits in order to cut costs. Retail chains seem to become prone to this once the whole organization gets big enough to put in place metrics that measure store performance mostly on a revenue basis and those in charge start to manage by the metrics instead of looking at reality because there is no more incentive for them to do just that.

Yep, my introductory programming course at university was also based on Oberon (actually, it was the second course, the first one was based on Miranda). I absolutely loathed the interface with the interclicks and crummy text editor. The concepts in the system were good. In my opinion it was just an utter usability failure.

Maybe this is exactly what they had in mind at Oracle when they first released their stuff or Linux...

There is a bit more background on "the other side" of this story with some more examples: http://www.thelogofactory.com/logo_blog/index.php/stock-logo...

There are a few interesting links to the artwork that is obviously showing up in other designer's work on StockArt.com and Jon Engle's work at reddit: http://www.reddit.com/r/reddit.com/comments/8ac0q/designer_g...

It's not clear who came up with what first. However, the other designers submissions seem to be consistent with their general style while there is not so much consistency in Jon's style. There are no upload dates though on the StockArt.com stuff. This might be fishy...

I fail to see how dwadle is radically different from the GameStop model. They only make 12% on a used game sale, so what? They are just cheaper than GameStop. They have the same incentive advertising the purchase of used games over new games as GameStop does. I don't think they are in a position to point fingers at their competitors as is done in the article. It is nice that you get real cash instead of store credit. On the other hand, as a seller you are competing with other sellers so you don't get instant credit like at GameStop. It's a choice everyone interested should be able to make for themselves. The remarks towards GameStop are uncalled for though. They should compete on a service/product level and not pull out some twisted ethical argument how they are better for the gaming industry.

The other big question: will they hardwire it to come up with "42" for "the answer to life, the universe, and everything" or will it actually source that "fact" from the web?

That is what you get for building your project on a proprietary platform. You are giving control to a third party and you better have a plan how to deal with the associated risk.

Along these lines, it strikes me as odd how people that would want to run open-source software on their own computers are completely content with running closed web applications where they have no freedom and no control at all. It may be the same reason people are willing to pay for bottled tap-water: convenience - it seems to trump other factors (including ethics and morality) by far.

The absence of something like a "Java Pet Store" for FP was what drove the topic for my MSc dissertation that I finished last year: I basically implemented a simple set of requirements for a publishing-workflow system in both Java and Haskell and then set out to evaluate the differences that the two approaches had from a software engineering perspective [http://www.lars-oppermann.com/dis/dis-lopperma-final.pdf].

The Haskell version turned out to be much more compact and some parts of the business logic could be expressed in a really straightforward way. The Haskell version also had a meta-programming based mechanism for automatically deriving and parsing XML representations of the domain objects. The persistence layer could also be made very unobtrusive due to Haskell's type-classes.

Nevertheless, the absence of extensible data types and the clunkiness of Haskell's record system made the domain model rather unwieldy. This is not a necessary limitation of FP. It rather seems that most users of FP today don't need such facilities because they are not normally building systems that require these kind of models.

It's also very important to note that object oriented programming and FP are not conflicting. Mainstream OOP languages tend to embrace an imperative execution model (Turing Machines) and FP languages are modeled around Lambda Calculus. Projects like Scala show how FP and OOP can augment each other nicely.

All whining about how running OSX on non-apple hardware ruins the "Apple Expiience"... Isn't this supposed for "love" of OS X cannibalizing the exact same thing it is evangelizing?

This is based on the assumption that Apple is able to develop a superior operating system because they can support the effort with hardware sales. If everyone would install their copy of OSX on hardware where Apple doesn't make money, how can they continue to improve OSX?

They might start to license the "right" to run OSX o hardware manufacturers but that would get them into the same compatibility hell Microsoft has gotten themselves into. I can very well understand how they don't want to get into that spot.

It's a nice pass-time and I don't think it hurts anyone given the small scale on which this is happening. Plus it may keep the folks in Cupertino on their toes for coming up with better hardware in the future.

Furthermore, as for the Linux comparisons. This clearly shows how Linux' most glaring deficiency is the lack of a consistent UI experience. There is a heavily fragmented mess bolted on top of dear old X11. It works - sort of - and as long as you stay within your chosen camp (Gnome, KDE...) you might not be off too bad. Sooner or later when you need other applications you'll get into toolkit hell.

In my opinion, a main reason for the situation described by the author is lack of architectural governance in large projects. The most senior programmer often is assigned the role of "the architect", even if he is more of a type that likes to obsess over details rather than the big picture. Such types are prone to dismiss the importance of conceptual integrity throughout a complex project which ultimately leads to the pile of unsustainable mess that many enterprise-class applications have become. Brooks laid out the importance of conceptual integrity pretty well in in the mythical man month. It is often not taken serious enough today.

Since when is it necessary for a color to be generated by a single wavelength of electromagnetic radiation? A good way to look at colors their perceptual relationships such as complimentary color is the color wheel used in the HSL and HSV color models. Magenta is at 324° by the way; that's between red and blue (more towards red). Going to the opposite side of the color wheel (324°-180°=144°) gives you (surprise) green, the complementary color to magenta. Magenta happens to be the area where the color wheel "joins" the opposite ends of the visible electromagnetic spectrum. There is nothing mystical about that fact which explains why greens is the only color that has a complementary color that is not made from a single wavelength.

My previous dablings into mobile app development were first with the old Palm OS (plain old C) and a bit of J2ME (oh the horror). Compared to that UIKit is bliss. I understand the python runtime is pretty compact. Thus I'd expect there to emerge solutions similar to what is currently done with C# code. Just wrapping the runtime in the app and having the code as resouces in the app bundle that get fed into the runtime when the application launches.

Which shows that we're not dying out. Yay!

You guys do realize that this is from 1999, don't you? It was really funny back in the day but I though everybody knew this by now ;)

Objective C is a really interesting language and the Cocoa and UIKit frameworks are designed in a way that makes great use of the features of the language. Is there something like KVO (key-value-observing) available in .NET with the newer versions?

If you want to have fun driving a Ferrari, you better learn driving stick ;)

With GCJ, the same should be possible for languages based on the Java VM too (including Java). Consequently you would be able to get Clojure, Scala, Groovy or Jython on the iPhone too.

I think most of the fame for actually pulling this off for Mono/.NET needs to go to the Unity engineers and not so much to the Mono gang. Although this is speculation on my part.

Yet another version: Do what you love and happiness will follow. How about that?

On that matter, I heartily recommend Tufte's "The Visual Display of Quantitative Information": http://www.edwardtufte.com/tufte/books_vdqi

Don't get that in mine. Maybe I got an older version since I didn't go through the US AppStore...

Yes it will be worth the effort. Alternatively, if you prefer a more modern book dealing with conceptual questions of programming in multiple paradigms in a similar spirit as SICP, have a look at Concepts, Techniques, and Models of Computer Programming (http://www.info.ucl.ac.be/~pvr/book.html).

If you work through this, make sure to catch at least some of the video lectures available at http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussma... Abelson and Sussman rock big time, plus: the outfits and hairstyles of the participants are just wonderful (mid-eighties!) ;)

Is it realistic to assume that a 3rd party application that can be customized to work with my database model can't be customized to work with a model exposed in some other way (web service, J2E, .Net or whatever)?

In rails the database is mostly a storage space for freeze-dried model objects. Your typical enterprise RDBMS woes don't apply. Migrations just make sure that the database scheme is consistent with your actual model. As far as writing Rails applications is concerned the actual technology used to persist objects is (mostly) abstracted away from the task of application design and development.

The model may still become a bottleneck if objects are tightly coupled and you can't scale out the model in a horizontal way. The low level nature and conceptual simplicity of the relational model allows database vendors to pull some pretty amazing tricks with scalability and clustering. People aren't building big database centric applications because they don't know any better (so I would hope). It all depends on the context. It shouldn't be the default because it can be inflexible.

Most importantly, back in the day 1998/1999 there was not much around that could match up to the functionality of PHP. Java servlets were not supported widely, Netscape had their serverside javascript wich required you to buy into their servers... Going with PHP was a no-brainer for any small web-shop/startup. With all the web stacks that are available today, it wouldn't have been that clear.

In my opinion the notion of implementing business logic outside of the database and acknowledging the longevity of the data are not necessarily in conflict. You need to have a well defined model and you can choose whether the database is a full implementation of that model or just a representation of the state of that model.

I don't find databases well suited for expressing complex behavior - programming languages are far better at that.

The solution to this is a multi-tier architecture. Only one application that implements the domain model talks to the DB and all other apps talk to that application. This doesn't give you the raw performance of a model living purely in the DB but may be a viable design decision. You trade flexibility for performance.

These are great examples towards the fact that the relational model isn't always the best way to go. Especially with regards to an evolving model. In object oriented models, polymorphism can be employed to extend an existing model with rather minimal impact. Introducing, for instance, a subtype for an address in a relational model isn't easily done. I'd rather model in OO land and use the DB as dumb object store. I haven't implemented a serious project based on an real OO database. Any experiences you guys would want to share with regards to model flexibility with an OODB?