I'll be speaking at a joint Ottawa XP and Ottawa STUG meeting May 29th at 6:30 pm. I'll b talking about XP in Smalltalk, highlighting some of the advantages of Smalltalk over other languages. My thanks go to Dave Buck for facilitating this!
I would have greatly preferred to see this in HTML (although not the atrocity that is HTML produced by Word - bleah) - but it's a usful summary of where RSS is.
I've been upgrading BottomFeeder and the blog all day - I added in the trackback module to the blog last night, but had to tweak that some today when I started looking at supporting it from BottomFeeder (the comment tool) and my posting tools (for this blog). In the process of doing all that, I now have the following:
This took a whole lot of testing before I was happy with it - and I still have to see how the blog deals with it in production.
Spotted this on Ted Leung's blog
The second presentation was on Model-Driven Development using Rational XDE. This just didn't do much for me, because I'm not a fan of RUP or ROSE, etc. I've used some tools to produce RUP diagrams from code, but I've never found tools like this to be helpful in the forward direction. Mostly they make it easier to deal with the structure of classes and objects, but specifying control flow via sequence diagrams is less efficient than banging out the code. Unfortunately for Rational, the speaker agreed -- he said he frequently writes code that he usese to generate the sequence diagrams. The presentation was short, and not that much of a product pitch.
Kind of funny that the speaker did that, actually...
There's a trackback module out there, and I'm in the midst of adding support for it to BottomFeeder. The idea is, when you use the existing Comment API support, BottomFeeder will try and send trackbacks to all the urls you reference, assuming there are matches in your feed list that list a trackback url in their feed. I'll be adding the same support to my posting tool as well - I really have to add a settings tool for that before I can release it.
I've updated the blog feeds here - I've added the Admin module, the Dublin Core (channel level only) module, and the trackback module. BottomFeeder has support for all of those except the trackback module - I'll be looking at that today.
I won't toss any spoilers - I know there are people who aren't near the end of the season yet (in Australia, for instance). It ended well, I thought - there were a lot of parts of the episode that reminded me of the end of season 5 - the feel was very much the same. I'm glad they went out well, instead of trying to pull it along for another year.
The end of Buffy the Vampire Slayer - I hope Joss wrapped it up well. I'd be watching right now, but the Replay is recording it, and I'd just as soon skip all the ads.
Ted Leung has some thoughts on standards:
In Why Standards?, Jim Waldo points out the difference between de facto standards and de jure standards. The most important point to be made is that standards bodies are not a place for invention, but a codification of existing practices. Rushing to standardize before there's enought existing practice to learn from is a mistake.
Very much the case. Smalltalk, for instance, standardized in the late 90s - at a point where it was becoming clear that namespaces (for instance) were an important need in the language - but also at a point where no one had done anything yet. I think Smalltalk ended up rushing to standardize....
Point your browser here to get the latest ObjectStudio EVOL build. After registration, go to the ObjectStudio section, and grab the EVOL. Enjoy!
Sun continues to wander down pathways others have trod before, while believing that they are the first ones to have visited:
The ACE project lets non-programmers draw programs by connecting boxes and lines. It's been tried before. Java developers will get a chance to check it out when Sun delivers the source code to ACE at JavaONE next month. "A common criticism has been that Java is very hard to use. Ace will bring the tools and facilities of Java to more people."
Wow, what a novel idea. Like this hasn't been tried before. According to the article, this is all related to the ACE project, which I've commented on here and here. It's simply amazing watching Sun.
Ok, so I'm looking at Trackback auto-discovery. Assuming the ref is on the page, this is pretty simple. However, I'm looking at Sam Ruby's site, and no such refs exist. And yet his comments are filled with trackbacks. So I do a little investigation, and we discover that the trackback refs are in the RSS feed. So let's say I'm using a posting tool - I make a reference to this site. How do I auto-discover the trackback url for a post? Well, I have to download each RSS feed (there are a bunch there), parse it, look for trackback refs (to the specific post, no less), and then glom that information into my post. Is it just me, or does that seem like a huge, huge waste of resources?
When I'm adding a comment, getting this ref is easy - the aggregator can just look at the post information, see if there's a trackback url, and go to town. But on the posting side, it's just ugly. Put the frelling references on the html page being linked to, and make life easier for all of us. Gads.
Scott explains the difference between code no one else will see, and code others have to deal with:
Even though no one else is looking at the Feedster code base, I'm starting to accept that it is a very real thing in the near future -- and that's scary.Now for non-engineers, you're probably thinking "Oh Scott, that's just a load of absolute hooey". Well here's an analogy for you -- I'm dealing with the mental equivalent of taking my clothes off with a new lover for the first time. Does that make it more clear to you? Now for an engineer who takes an awful lot of pride in his work, this is a big deal. And just as one might go to the gym or dress up before a new lover, I'm doing the same. Of course my work isn't going to the gym -- it deals with "dress up" routines like:
- Commenting
- Clean up
- Re-organization
- Re-factoring
But you know what? Its pretty much the same thing. Oh and in case you are wondering, yes, I can relate most technical issues to the male / female interaction. Not sure what that says about me (and no comments on that one).
Yes, I've noticed that I tend to be a whole lot more careful with BottomFeeder code than I am with the blog code - probably because other people are contributing to BottomFeeder - as Scott says above.
I've gone ahead and implemented the Blogger API and the MetaWebLog API in my blog and the front end posting tools. I have no plans to actually post the blogger and metaweblog servlets - those apis pass usernames and passwords in the clear - something I'm not about to do. Still, having the client support will allow me to post at least a rudimentary blogging tool for BottomFeeder with the next release. There's a ton of refactoring to do - it's all pretty sloppy at the moment!
Bob Martin has had enough of protocol madness:
I was on a conference panel recently. Someone in the audience asked a question about the future of SOAP and other similar messaging middlewares. The panelists all answered in various interesting ways. When it was my turn I just said: "I'd rather use a socket." To my surprise I got a polite sprinkling of applause in response.I think we have gotten framework happy. If a framework exists we feel honor bound to use it. We are like the construction workers in Don Adam's "Hitchiker's Guide to the Galaxy" who were building a bypass through Arthur Dent's house. When he asked them why they were building it they said: "You've got to build bypasses."
I think the industry should join frameworks anonymous and swear off gratuitous framework adoption. We should all start using sockets and flat files instead of huge middleware and enormous databases -- at least for those applications where the frameworks and databases aren't obviously necessary.
I can agree with that. Complexity just wends its way through the software industry....
To more conferences that is. Gordon Weakliem describes his impressions of the Rocky Mountain Software Symposium:
Favorite session: Dave Thomas' Ruby For Java Programmers. I'm interested in Ruby but figured that I'd never get around to looking at it, but Dave inspired me to download it today. I love the idea of blocks.
If you like blocks, visit why smalltalk and give one of the Smalltalks a whirl. You won't regret it :)
There's more:
You could've gone to the conference and never talk about Java, practically. James Duncan Davidson did 4 sessions, none on Java (my biggest regret is not going to one of his sessions). The closest you'd have to get to Java is Stuart Halloway's 3 hour session on "XML Schema for Java Programmers". There were 4 sessions that discussed .NET, on on Objective C, plus Dave Thomas' Ruby session and his overall "try Ruby" mantra in the keynote and panel discussion. It's half scary, and half really cool. Really cool in that it's a gutsy thing to talk about the "competition", scary in that I felt like I might be looking at the future of Java - except that there was no Java, at least not as we know it today.Dynamic typing seems to be much less controversial that I expected. It seemed like the goodness of dynamic typing was pretty much moot in the panel discussion. Talking to some other attendees, I'm not sure if the message sunk in though. Dave Thomas gave some great reasons why Java's type system isn't what it's commonly believed to be, though I still think that the best argument is that once code hits the network, all typing is dynamic.
The world is ready for Smalltalk - is Smalltalk ready for the world?
Lots of people are talking about NewsGator, an RSS reader that plugs into Outlook. Even if I wasn't writing BottomFeeder, I wouldn't use anything that relies on the virus attracting menace that is Outlook. I don't have the time in the day to spend keeping up with security patches. I'll stay with Eudora, thanks.
I posted here on MS paying SCO for access to Unix patents. Via Sax.Net comes this speculation:
Even if the licensed source and patents were completely useless to Microsoft, they would still greatly benefit from this. By providing cash to SCO, Microsoft is effectively sponsoring SCO's legal maneuvers against Linux. A strong cash position for SCO reduces the chances of a near-term settlement with IBM.
Fascinating. Could be the case, and it would certainly give SCO enough money to cause a few headaches.
The New York Times (registration required) has taken notice of Wikis as a possible business tool:
Whether wikis will make it in the mainstream business world, though, is an open question.Software programmers have sought for decades to design products that help people collaborate in the virtual world as easily as they do in the real world. E-mail is by far the most successful result, but it is linear and best suited for back-and-forth communications involving two people or a small group. On the other end of the spectrum, groupware programs like the Lotus Notes software sold by I.B.M. are elaborate attempts to mimic work environments, with multiple levels of authorization, defined work flows and lots of rules - just like a corporation.
The most distinctive characteristic of a wiki is that anyone in the group (or for public wiki sites on the Internet, anyone who visits) can edit, modify or even delete material on the pages. Such a free-form collaborative process can be messy and chaotic, and it requires a commitment to the group that may not sit well with some egos. But over time, wiki advocates say, a group voice or consensus emerges into what some enthusiasts call "emergent intelligence."
The creative anarchy of the wiki is the philosophical inverse of conventional corporate groupware software. Groupware's highly structured rules and processes do not always reflect the way people really work. Employees often ignore costly corporate-sanctioned software and revert to informal social networks - whether simply e-mail or impromptu water-cooler discussions.
Ward Cunningham, who created the first wiki in 1995 and is the author of "The Wiki Way," a manifesto and how-to manual published by Addison-Wesley, says a wiki is a medium for connecting an electronic community and allows "idea keeping." A wiki presents its members with a blank slate, and their entries determine its structure and organization.
They even point out that there's a market for them - they reference a commercial Wiki vendor (SocialText>http://www.socialtext.com/]), which seems to be a small startup:
The SocialText software, which starts at a price of $995 a year for five users, is being used in about 20 companies, typically small businesses or departments within larger ones, according to Ross Mayfield, SocialText's chief executive
The Smalltalk team at Cincom was an early adopter of Wikis - we run a variety of internal and external wikis, and have found them to be highly useful for sharing information. One thing that we have found - of all the readers, a limited subset will actually add content. And of that subset, a smaller group will do wiki maintenance - cleaning up dead links, re-organizing pages thathave gotten too chaotic, etc.
There's more stuff out there on RSS and bandwidth:
RSS Bandwidth Usage We're all starting to see the inevitable issues with RSS bandwidth usage. Something that occurred to me in the shower that I haven't heard anyone talk about (although I am a veritable newbie compared to people like Dave Winer, Ben Hammersley, Bill Kearney and others) was can the feed itself specify the allowed polling interval ? I.e. if you're me and you update your blog constantly then I'd want to allow a fast polling interval but a lot of us don't update as frequently and they could set a daily interval. Or has this been hashed out, discussed and I'm just clue free ? And yeah I know that some aggregators would ignore it but it could be implemented as a default setting that the user manually forced if they needed to. The same way you can force a browser to refresh.
IMHO, the whole feed polling thing is a hack. BottomFeeder supports it, but there's a simpler answer (which Bf also supports) - conditional-get. You send a small query to the Http server and ask if the doc has been updated. If it hasn't, you get a documented answer, and you don't fetch the whole ything.
This is the prior art - it was invented years ago to solve scalability issues at the server. Http already has an answer to this problem. the various proposals to implement hacks with update intervals on fully dynamic feeds will make the problem worse, not better - let the Http server do what it's good at, and push out a static feed. Have aggregators do the right thing, and check for updates before pulling the whole feed. It ought to be simpler to have aggregators support the existing infrastructure (which works, btw) than to support some new thing which purports to solve the same problem.
I really dislike the kind of patent suits that SCO has brought, but from this story it seems to be working. MS is buying rights to Unix sources:
No financial terms are being disclosed in the deal, under which Microsoft will license SCO's Unix patents and underlying technology called source code. But Microsoft's move suggests that the software company's lawyers view SCO's patents as important, and could encourage other companies to strike similar pacts.
Spotted via the .NET guy
There have been a number of posts on mobile blogging (moblogging, they call it) using a cell phone as the interface. Is it just me, or is that the most useless idea ever? I can think of few things more irritating than trying to add a post via the tiny phone number pad. I really don't want to read acronym laden phone posts either - wait until you have a keyboard handy....
On Windows, BottomFeeder can read in the IE Favorites menu. Up until now, it's just been building a matching menu and slapping it under the Browse menu. Now, there's also a set of pseudo-feeds for each menu category added to the main tree. That makes accessing Favorites easily possible without leaving BottomFeeder.
Via Coding the Web comes this example -
Then I just saw this posting from Jason: Last night my journal was hacked. All of my Movable Type weblogs were deleted and the archives destroyed. Looks like they got in by just using my username and passwd which is not good.
This is why my posting API uses encryption, and why I don't support the blogger api on this blog - that pathetic excuse for an API passes usernames and passwords in the clear
Rich Demers has been busy reorganizing the BottomFeeder documentation - I'll likely post a 2.9 and dev update to point to these shortly:
The Module Support thus far is documented here. I'll be updating the page as things develop. I've copied the list here as well, but that link will have ongoing updates....
I've added a search by category in BottomFeeder - as well as an aggregated search by (title, body, category). Additionally, you can select an item in the item table and execute a search by that item's category or title.
Via Manageablity comes this link to Wininformant magazine
So now it's April 2003 and I'm hearing that .NET is dead--that Microsoft will continue downplaying both the name .NET and the technologies behind it. You can find hints all around that this ".NOT" strategy might be happening right now. The 64-bit versions of Windows Server 2003 (once called Windows .NET Server, by the way) contain absolutely no .NET bits at all: No .NET Framework and no ASP .NET. Exchange Server 2003, the company's next major messaging server, contains no .NET. Office 2003, the premier office productivity suite, contains XML functionality only in the high-cost business versions and contains few native .NET features. In the biggest year ever of new product introductions from Microsoft, few if any of its products promote .NET, its supposed vision for the future.
I can't say that I follow this stuff closely enough to know what's going on; still, omitting.NET support from the 64 bit platform does seem curious. Is it work delayed because MS thinks that 64 bit migration will be slow, or is it a de-emphasis of .NET? If it's the latter, it could easily be an issue with the huge installed base of VB developers not wanting to make (what sounds like) a difficult move to VB.NET. Whatever the reason, it's interesting - and bears some watching.
Via Ted Leung comes a report of another dynamic/static typing dustup at the Rocky Mountain Software Symposium:
My thoughts about inheritance have been evolving since I learned Java. The revelations I've had may not seem like much to a Smalltalk programmer, but they represent a complete shift in my thinking.
Nearly every introduction to OO concepts I've ever read or seen has dealt with inheritance very early, and then moved on to a cursory discussion of "polymorphism" as a sort of nice side-effect of inheritance. Partly as a result of this (and partly because of the underlying misunderstanding) the word "inheritance" is usually used to refer to some combination of behavior inheritance and subtyping.
Java is the first language I have used that mostly separates those two concepts. Extending or implementing an interface represents a subtyping relationship, whereas extending a class represents the more traditional combination of subtyping and behavior inheritance. The process of using and designing with interfaces has brought subtyping out of the shadows and into the foreground of my thinking
And the conclusion drawn:
I realized almost immediately after posting that that Smalltalk and its ilk (including, for example, Ruby) have essentially the characteristic I was talking about, where subtyping and inheritance are separate concepts. With those languages in particular, that distinction is present because there is no subtyping at all ... the notion really doesn't exist in those languages, because typing as Java and C++ folks think of it doesn't exist.
As soon as you see what unlimited polymorphic behavior can do for you, it's a real kick in the pants. I'm very pleased to see that the ideas that came out of Smalltalk (and Lisp) are finally coming to light in the wider developer community.
Well, that was maddening. I've noticed that using pre tags (to escape code posts) has caused me grief here. I just figured out why. For presentation purposes, the server converts all CR characters into <br> tags. That's what I wanted - but it used to wreak havoc with tables I'd post - having br tags scattered through the table caused all sorts of interesting display issues. So I had the server look explicitly for table tags, and not convert within them. Turns out that doing the same with the pre tags gets rid of some presentation glitches as well. The joys of HTML....
I used to teach the ParcPlace Introduction to Smalltalk Class. Years later, I remember what used to happen on Wednesday when AspectAdaptors came up - a collective huh???, followed quickly by a blank, glazed-over-eyes stare. The confusion hasn't eased over the years; I still see many questions on this, even from experienced Smalltalkers. So what are they, what are useful for, why do you want them?
Well, consider a simple VisualWorks application - a class Counter with one instance variable - count. Here are some methods:
count: aNumber
count := aNumber.
count
^count.
add: aNumber
self count: self count + aNumber.
All pretty simple, right? Now let's have a UI on that - a simple UI that shows us the current value of the count, and gives us a button - each time we press the button, we send #count: to the Counter instance with an argument of 1. easy to enough to string together, but how do we get the UI to be aware of the changed value in the count variable, and display the new value? Well, there are two routes to follow - the MVC dependency model, and the new trigger event system. Here I'm going to use the MVC model - I'll post an alternative using events in the future.
Ok, so the first thing is to change the #count: method as follows:
count: aNumber
count := count + aNumber.
self changed: #count with: aNumber.
Ok, that signals a change in the Counter object - but how does the UI pick it up? Well, one (complex) way would be to make the UI a dependent of the Counter object, and then implement an #update:with:from: method. This method might look like this:
update: anAspect with: aValue from: aModel
anAspect = #count
ifTrue: [self counter value: aValue].
There's an obvious problem with this - as the number of objects of interest (in the domain and in the UI) grows, the #update method grows into a complex case statement. There's got to be a better way, right? It turns out that there is - AspectAdaptor. This object does exactly what the name sounds like - it adapts messages that are sent by the domain into ones that are understood by the UI. If you used the VW GUI builder, and your UI class has an input field for displaying counter, then you have a method that looks like this:
counter
"This method was generated by UIDefiner. Any edits made here
may be lost whenever methods are automatically defined. The
initialization provided below may have been preempted by an
initialize method."
^counter isNil
ifTrue: [counter := 0 asValue]
ifFalse: [counter].
That's defining a ValueHolder - a wrapper around a number in this case. We want to replace that with an AspectAdaptor. Here's what that looks like:
counter "This method was generated by UIDefiner. Any edits made here may be lost whenever methods are automatically defined. The initialization provided below may have been preempted by an initialize method." ^counter isNil ifTrue: [counter := (AspectAdaptor forAspect: #counter) subjectChannel: self model; subjectSendsUpdates: true] ifFalse: [counter]
That assumes that you have a line like this in #initialize:
model := Counter new asValue.
So what does the adaptor do? It sets up the communication channel for dependency updates for you automatically, on a per-object basis. The adaptor is now a dependent of the Counter object, and is specifically looking for the #counter aspect when updates come through. Note that the aspect is set to #counter - it's entirely possible to have the get/set messages be different. But AspectAdaptors are more than one-way conduits from the domain up - they are also conduits from the UI down. If you allow user input, a change in the UI will be pushed to the domain. Have a look at the class comments for AspectAdaptor and ProtocolAdaptor (its superclass) to see what's going on.
What if you don't want changes going down as each field on a form is changed though - what if you want a form level update? Have a look at BufferedValueHolder. You can use that to control when updates flow down, via a true/false switch.
This is all documented in the GUI developers guide as well - you should read that over for a more in-depth explanation. If you have questions, send them to me
Today's Dilbert strip skewers the multiplicity of management theories - but I think it could just have easily been skewering development methodologies....
Interested in TDD (Test Driven Development)? Check out Keith Ray's post on available resources.
Interested in TDD (Test Driven Development)? Check out Keith Ray's post on available resources.
Charles Miller explains how Agent Smith has re-licensed himself using the GPL. Hehe.
There's a nifty piece over at Loosely Coupled on the current attitude towards IT spending. The basic problem - after so many promises, companies are a little unwilling to invest in the next big thing - because the last big thing didn't rally deliver. Here's the idea:
Loosely coupled architectures enabled by web services are going to bring the same waves of incremental innovation in IT - and in business - and the only IT that is going to be shown up as not working is the highly structured and centrally controlled architectures of monolithic, enterprise-scale computing systems, whose design philosophy owes more to the values of the industrial era than to the needs of the emerging information era.Unfortunately, as I noted recently after listening to a debate on the potential value of investing in web services, "Businesses have had so many false bounces in the bear market of IT expectation that they just can't bring themselves to buy any more." John is right to speak of a "backlash". In many organizations, that backlash is going to throw out the baby of distributed services innovation along with the stale bathwater of inflexible enterprise-scale computing, just at the very moment when businesses should be buying into the new distributed architectures.
He's probably right about the benefits of web services - they offer the opportunity of stitching together truly best of breed systems from component parts, instead of the dangerous all in one nature of past promises. Can you blame companies for being gunshy though? Look at it from the business side - the IT group has switched technology bases how mahy times since 1993 - and, in terms of business benefit - to what end? Tons of money was spent on Java conversions, for instance - and the best end result of that was for the IT shops to end up right back where they started before the conversion. Again, from the standpoint of the business folks, what did all that spending accomplish? Precious little, which is why they are so unready to invest more - especially in a down economy.
Via Dewayne Mikkelson I found this top ten Buffy moments list. It's a good collection; not a lot to argue with. Go check it out.
The schedule for Smalltalk Solutions 2003 in Toronto is online. We will have this posted to the Smalltalk Solutions site shortly - in the meantime, check out the list of speakers, and go register!
There's going to be a roadshow in Germany this summer - check back to that site, the content will likely have more information by early next week. If you'll be in Germany in June, check it out
I'm reading along in the Sax.NET blog, and stumble across a screed on why RSS should mandate XHTML instead of escaped markup. Sigh. Not this silliness again. On the one hand, this guy quotes Don Box:
Escaped markup has more momentum and history. It's the easy path if the goal is to ratify the vast majority of feeds currently on the Internet. XML-based markup (XHTML or otherwise) requires more courage, energy, and time. I personally think the upfront investment will reap pretty significant rewards pretty rapidly, but ultimately, it takes a village to pull this off.
He agrees with this. But hang on a sec - XHTML will require more time and energy, and there's no tool support. Escaped markup is, what - esthetically unpleasing? It works, browsers (and other tools) understand it fine. XHTML is harder to produce, and tools don't support it. There's a simpler question though - to the end consumer of a feed, what's the benefit? None. That's right, none. It will look the same either way. What about developers? Well, there's a need for new tools. Here's my question: why bother? Here's the justification:
I agree 100%... RSS is all about not allowing markup to sacrifice the structure of information. Mandatory XHTML will make RSS stronger and more useful. With XHTML markup we can have the best of both worlds: rich, creative expression, and unlimited, deep querying, indexing and transformation of the information.
Yeah, sure. An XHTML based markup will support the possibility of additional things layered on - but it seems like an awful lot of work for a presumed benefit. IMHO, it's not the simplest thing that could possibly work....
Over in cls, Lance Parkington weighs in with more on Smalltalk, .NET, and Java:
- Please note that Smalltalk (VisualWorks) does NOT wreck development machine a major saver of developers time! dotNET makes a complete mess and trashes the Windows Installer so VisualAge 3.5.x/4.x cannot be installed and probably little else can be installed successfully (ie anything using the Windows Installer) without manually editing tables in the .msi files. Also Sun's JDK's will then no longer work regardless when installed so pure Java cannot be used/tested after dotNET installed. To test dotNET applications really needs machine not installed with the development environment! This is considerable overhead.
- Java Bean development (public serializable classes) probably best carried out using VisualAge since generated code can be pushed through the Sun JDKs (pure Java). Generally Java takes 3-7 times as long to program same application as Smalltalk. This is partly due to need to define TYPE of variables before use requiring more thought, difficulties processing collections (no SortedCollections in Java out of the box), and general syntax issues (eg semi-colon, bracket emplacement). There is also more code in Java required to represent same functionality as in Smalltalk and this has knock on effect on productivity ie number of correct lines of code produced per day. Complex mathematical or logical classes will take long time to write and debug. It is also possible to save classes that have failed to compile in Java causing problems when applications cannot run! J2EE is generally too complicated and unreliable for everyday use and standards do not appear consistent in the major implementations!
- Smalltalk is generally the most productive language of all but suffers since expensive for academic/commercial use and poor support is available on the web for some of the more complex applications. There are very large gaps of information between introductory concepts (eg the Manchester archives) and advanced capabilities of current software vendors offerings (hidden in huge PDF files) that hardly see the light of day. Java support is generally better and if programmer is stuck it is generally quite easy in Java or C++ to find out quickly how to do something. Time and money are everything and gold plated solutions cannot be afforded when quick results are required by yesterday!
Things are better on the Smalltalk code front - for VW, check the VW Wiki and the public store. There are a fair number of Open Source projects going on in VW, being tracked in the public store. As to PDF files, Google indexes those - try a search.
I posted earlier on a cls thread discussing Smalltalk, Java, and productivity. Alan Knight weighed in:
As I recall, although I heard the quote in a different context, he was specifically referring to working in VA/Java, which is as close to a Smalltalk environment as you can get in Java.A couple of other celebrity testimonials grin
I firmly believe that there are two types of developers: Smalltalk programmers and everyone that wasn't lucky enough to be a Smalltalk programmer. Smalltalk is my language of choice because it is pure OO - you have objects and you send them messages, that is all. In Smalltalk, even classes are objects. Scott Ambler, author of a great many technology books (and a keynote speaker at ST Solutions 2003). This bit goes on at some length.
Although it's now a long time since I did anything with it, I nominate Smalltalk, I still haven't come across anything quite like it for being able to transfer thoughts into computer code. It's not just the language: It's the wonderful browser environment, the libraries, and the culture of writing clear, well-designed code as quickly as anything else can crank out spaghetti. When the participants at JavaOne were extolling how Java was so much more productive than anything else, I needed a brown paper bag. Oh well, back to sorting out my classpaths... Martin Fowler , (Software Development Magazine , Jan 2001)
So, Bob Martin's prediction for this decade: Keep an eye on languages like Python, Ruby, and Smalltalk. They are likely to become extremely important. Robert Martin, of ObjectMentor, one of the leading Agile/XP training companies.
"My absolute favourite language is Smalltalk." Grady Booch Software, Development Magazine, Sept 2002. (Of course, Grady immediately follows this with "I only wish it had survived". Fortunately, rumours of our death are greatly exaggerated).
See also Ed Klimas' site, where Ed Klimas, who does a lot of work with function point measurement on projects his company is involved with, has a quick summary.
More good stuff. There seems to be a pattern here....
Keith Ray has a blog I didn't know about this morning until he sent this comment to this blog. Check it out, and grab his feed here
Rich Demers points out that blog posts are transient. Even with the search function, that's true enough - it's not as if I've been entirely consistent in my categorization, and it's hard to find something if you have no idea what you are looking for anyway. Why Smalltalk is a great place for Smalltalk articles - but not everything is going to end up there. In the meantime, I've got a small list of VW tip posts I've made here.
A few days ago, I added module support to BottomFeeder - and I made a fairly dreadful mistake in data classification. With the pubDate or dc:date items, you get sent a timestamp in either RFC822 or ISO8601 format. At the time, I was lazy and just kept thos timestamps in a string format. This is problematic on a few levels:
So what to do? Well, in VW there's a neat feature for serialized objects - schema migration. Say I have a class that looks like this:
Smalltalk.RSS defineClass: #RSSItem
superclass: #{RSS.RSSAbstractTextObject}
indexedType: #none
private: false
instanceVariableNames: 'read guid commentAPIUrl descriptionModule contentModule commentModule category pubDateString '
classInstanceVariableNames: ''
imports: ''
category: 'RSSViewer'
Now, let's say that the objects stored on disk don't have the last item - pubDateString - because I just added that. No problem. Implement as a class method something like this:
binaryRepresentationVersion "for managing schema migration" ^'1.0'
The previous version (the one on disk) will have a nil version. Now, add this method:
binaryReaderBlockForVersion: oldVersion format: oldFormat " An attempt is being made to read instances of an obsolete version of this class. Answer a block that converts old instances (represented as an array or string of instance variable values) to new ones." oldVersion == nil ifTrue: [^self nilBinaryMigrationBlock].
Now, whenever you use BOSS to bring in serialized objects, the objects come in and get sent through this code to check for schema migration. The next question is, how do you implement the code that does the actual migration?
Here's how you do that:
nilBinaryMigrationBlock | inst | inst := self basicNew. ^[:oldObj | | newObj size | size := oldObj size + 1. newObj := Array new: sz. newObj replaceFrom: 1 to: size - 1 with: oldObj startingAt: 1. oldObj become: newObj. oldObj changeClassToThatOf: inst].
We grab the old object in the form on disk, get the old values, and stuff them into a new instance. We then use reflection to transform the old object into the new object. Now, recall my initial problem - I had objects on disk of the same size (i.e., number of instance variables) as the new one, but needed to go from string to timestamp. Now problem. At the very end of the block, I added a message send to a new method: #stringToTimestamp: that did the conversion.
This is a very powerful technique, and one I've used a lot - not so much the data conversion as the shape change. This blog, for instance, started back in June 2002. My blog entry objects are actually saved not to a database, but to date stamped binary files. I've been modifying the blog code continually over that time period, and have added things like categories, trackbacks, etc. I've done all of that with schema migration, as above. The nice thing about this is that I don't have to read in all the files and do a conversion - they can happily stay on disk in their old format, and only get converted when (or if!) they get read in (for instance, as the result of a search). BOSS may be an old part of VW, but it's a very useful part, with a lot of neat features.
I spotted this in comp.lang.smalltalk. The link is to the original post - Niall Ross answers:
One can make the point that this is the only data there is. Noone has published any data telling a contrary story (that I know of). Making a decision based on scanty evidence is wiser that making a decision against what little evidence there is.Lacking more data, one can sometimes use big name quotes, e.g.
- Kent Beck (Mr XP) said (at ESUG 1999 in Ghent) that, "I program at a third of my Smalltalk speed in Java."
- Bran Selic (RealTime UML guru, built the tool that is now the RT part of Rational Rose) said (at UML 2000 in York) that, "I was sorry to see Smalltalk lose out to Java because Smalltalk was the only language in which I noticed a real difference in my productivity".
As both these people make money from selling books that Java programmers buy, providing tools that Java programmers use and attending conferences that Java programmers go to, they have no commercial motive for the above remarks.
Of course, if your manager's reaction to the name 'Kent Beck' is to say, "Who?", then this won't achieve much.
the Gartner Group numbers are for initial Java projects, where the lack of experience is the major risk, and you will face (to a lesser extent - because Smalltalk is simpler than Java) a similar risk when doing your first Smalltalk Project
Quotes from people saying that Smalltalk is the ideal language for teaching and learning OO can be found easily and might address any management concerns. Be sure to get a couple of good books and a Smalltalk-aware coach to make the initial change.
Good stuff.
Via the Fishbowl we get an explanation of why closures are useful, and why you won't see them in Java:
The advantage of closures is that they allow you to add new control structures to your language. Java 1.5 is looking to introduce a foreach construct to iterate over lists. With closures, such language constructs become unnecessary (Ruby has only very primitive native looping constructs) because you can define your own. Similarly, closures allow you to dispense with boiler-plate wrapping code such as we see everywhere with file or database manipulation in Java.
That's part of the reason Smalltalk is so much more productive than Java - mor expressive power. Why won't you see it in Java? Charles explains:
You can approximate the functionality of closures in Java using anonymous inner classes. There are two problems with this, though. Firstly, anonymous inner classes are unnecessarily verbose. Closures are supposed to be a short-cut, and anonymous inner-classes are anything but. This can be got around by adding some syntactic sugar to the language of course, but the use of classes is still quite heavy-weight. (Each anonymous inner class is an additional compilation unit, for example)The bigger problem is that anonymous inner classes in Java don't really close over their surrounding scope - they cheat. The best way to demonstrate this by example is this:
i = 1; 1.upto(100) { |num| i *= num; } puts i;The above code prints out the factorial of 100. As you can see, the variable i is modified inside the closure, but because the closure is executed in the surrounding scope, its value is changed afterwards. This is unlike the behaviour of a regular function call, where variable values in surrounding scopes are not changed.
If you tried to write the equivalent code in Java, it wouldn't compile. Java doesn't really close over the surrounding scope, it copies it. To hide this implementation detail, any variable referenced inside the inner class must be declared final outside it: which is fine if your inner class is manipulating a mutable reference type like a list, but breaks if you want to work with immutable reference types, or value types. (i.e. Strings and numbers)
This is why you're unlikely to see closures in Java, sadly. To implement them properly would involve making changes to some pretty fundamental parts of the JVM. It's a pity, though, because they're damn useful
It's a pretty good read - gives examples in Ruby, which is explicitly modeled on Smalltalk.
A couple of days ago I posted a dev parcel for BottomFeeder that did not read in the 2.9 format feed file - which was a problem. Turns out I messed up the schema migration block when I was doing the module support. That's fixed, so if you try the dev build now, everything should be ok.
After seeing a few bloggers report in on Matrix Reloaded, I had low expectations for it - but it was pretty good. The pace was fast, the effects good. Some of the lines fell flat, but hey - you aren't watching it for plot, right? A good movie, not a great movie. Worth a trip, not worth multiple trips, IMHO.
There will be a nicer announcement forthcoming, but Smalltalk Solutions 2003 is going forward - July 14-16. Go visit the site and register - what are you waiting for?
Later today I'll be changing the dynamic servlet - I'll have it check the http headers for the relevant 'last-modified' information, and send along just the newer stuff. That should work with decent aggregators. Like, say, BottomFeeder.....
The early reviews sound disappointing, so my expectations are low....
Here's an obvious headline for Booch: Language Once Was Key - Now It's Design. Heh, almost as much of a shock to see the UML guy pushing design to the front as it is to see me pushing Smalltalk to the front :)
Here's the link to the story. The basic claim is that .NET and web services obliterates the importance of any particular language - since all can play equally - and elevates design. Go have a look and see what you think.
Via the .NET Guy's comment feed comes this beauty;
What people should do is use aggregators that don't go polling each and every hour for new content, but that collect the feeds when you are going to read them and hit the refresh button; like Aggie does, for example.I guess many people here will leave their computers on at night, and with the session locked out. This means a bunch of refreshes (and consequently, bandwidth) that go unused :(
What's the purpose of automatic refreshing? Do you interrupt your work when you see there is new content awaiting, or just browse blogs while taking a break? Or perhaps is me, who mostly finds new content awaiting by the morning (living in Europe and mostly reading US-based bloggers...) and thus sees no point in auto-polling each hour. I guess there are many behavioural patterns with regard to blog reading... someone should write a paper about it.
sheesh. Replace RSS Reader with email client - should we get rid of periodic polling in those as well? See, I work during the day, and like to periodically see if there's new mail or new news without having to add an extra step. My reader uses conditional-get, supports gzip encoding, and also respects the update frequency tag (if in use) in RSS - both ttl and the newer ones in one of the modules. Which means that it's pretty light on the polling side.
Via Lambda the Ultimate - Here's a reality check on static typing as security:
We present an experimental study showing that soft memory errors can lead to serious security vulnerabilities in Java and .NET virtual machines, or in any system that relies on type-checking of untrusted programs as a protection mechanism. Our attack works by sending to the JVM a Java program that is designed so that almost any memory error in its address space will allow it to take control of the JVM. All conventional Java and .NET virtual machines are vulnerable to this attack. The technique of the attack is broadly applicable against other language-based security schemes such as proof-carrying code.
So much for that theory....
I added an incremental feed. The server keeps track of when you last queried, and only answers with new content since then (if any). Some of the proposals I've seen floated for this rely on client-tool help with cookies, or something in the feed. This solution does not rely on the client at all.
I was looking at the .NET guy's blog and saw that he's a little worried about bandwidth based on RSS requests. I got pointed to this by Michael Lucas-Smith (one of the TypeLess guys), and he said I ought to write something in the way of a dynamic feed. Here's the issue:
Simon Fell remarked that he's concerned about the bandwidth from RSS on his site. His site supports HTTP caching properly, so it's probably not that big a concern.One very prolific blogger (no need to name him, since it isn't his fault) is using a tool that does not supporting HTTP caching properly. Right now, his RSS feed is 302K. Think about that: 302K x once an hour = 7.1 megabytes per day, per subscriber. Have one thousand subscribers? 7 gigs a day. And you know what? What this person says is too valuable for me not to subscribe to his feed.
Yeah, I'd say bandwidth is an issue for some people.
This sort of implies that, sooner of later, we're going to need to leave static RSS behind and support dynamic RSS -- perhaps even a push variant for some people (although with HTTP caching, what you're saving there is a bunch of connections, not any significant bandwidth, until you're really up into the big leagues).
So, instead of bickering about XHTML in RSS, how about we hammer out a new syndication system that's a little more dynamic, so that we only get the new posts when there are some, and not get any data at all when nothing is new?
I'm less worried than the .NET guy; then again, he's likely using IIS, while I'm using Apache. I'm also using Smalltalk, so even though I don't care that much, I whipped a servlet up in between watching tv shows this evening. The servlet keeps a cache of IP addresses and the relevant (latest) item grabbed from them. On each request, it only answers things newer than the last request. I'll get around to deploying it tomorrow; it's late, and I'm tired....
Over on the .NET guy's blog, there's some interesting information on SQL Server and Stored Procedures:
Frans Bouma publishes data that some people find very surprising, namely that his testing showed there was no performance advantage to stored procs in his case. I didn't find this surprising at all.There's a general performance improvement that went into SQL Server 2000 (I believe) w/ regards to dynamic queries: that is, if you use parameterized queries, SQL Server can plot an execution plan for the parameterized query and cache it, and then next time that query comes through, use the already stored execution plan (despite the data being different). That basically kills the performance argument, because the advantage of a pre-calculated execution plan is eliminated. (In fact, it seems that I remember reading that sprocs in SQL2K weren't even stored in compiled form; rather a new execution plan is created and cached the first time it's executed, but I could be wrong on that.)
Now that's interesting. I'll have to take a closer look at the benchmarks, but that sounds very interesting. If that holds up, it should make O/R mapping simpler. Along those lines, the next thing in that post:
Now take this to the next step, as Paul Wilson does in Frans' comment area. Why not an O/R mapper? I have a strong feeling that Yukon will prominently feature the framework for treating SQL Server as though it were an object database.We've taken it one step farther than an O/R mapper in our product, as the database stores very little in the way of relations (only the many-to-many mappings for query purposes). Objects are stored opaquely in the database and rehydrated dynamically as needed. But that's a story for another day. :)
Fascinating. Is Oracle doing anything like this, or IBM? Does this hold up for complex databases?
Via Rob Fahrni - what's up with this? Follow that URL, and see if it opens your CD drive...
I check Feedster every so often to see what's being said about Smalltalk. Today that got me here, where I saw this and this. Here's an excerpt:
Recently I've been working on a small application which slurps a huuge dataset into memory, processes it for a bit and then writes some measurements out to disk. Now, it just so happens that I don't know exactly how to process the dataset to get the best results. Maybe I need to use an offset of 35. Or maybe it'd work better if I used 70. I don't know until I've tried a few values to see what works.Dataset dataset("input.dat"); Answer answer = Process(dataset, 35); cout << "The answer is " << answer << "\n";Reading the dataset into memory takes a good thirty seconds or so. So, I run it with "35" as the parameter. Ooh, that's really terrible. So, change it to "50", recompile, run the application. Wait another thirty seconds for it to reload the dataset. Zzzz, this is silly. Why do I need to reload the dataset each time?
This is the problem with C++. There are two seperate worlds. You start in the "source code world" which is inhabited by variables, type and comments. Then you pass through the Portal Of Compilation to reach the "executable world" which is inhabited by data, stack frames, and heap blocks. You're not allow back into "source code world" unless you throw all of your possesions into a big black hole, upon which they vanish forever,
Instead, I'd write a little bit of code which loads up the dataset, then switch into "executable world" and run it. Then I'd say "just wait there" to my stack frames and the heap while I nip back into "source code world" and write the next bit of code to process the dataset in some way. Then I'd return to "executable world" to run that code, see what the result is and then nip back to tweak my parameter. The "executable world" would always stick around, even though I'm changing the code.
Now, if you've only coded in C/C++ this will seem crazy. These language are a bit like a little wind-up car toy. You spend a while winding up your program, and then to run it you put it on a table and let it go .. and it goes "wheeee" and careers off in some random direction for a while until something goes wrong. So, you pick it up, wind it up some more, and try again. Wheeeeeee, it goes off in a slightly different direction to meet a different fate.
With smalltalk or lisp, you're not just a passive observer who watches as the car races off to its doom. You are actually sitting inside the toy car, keeping it on course. If the car drifts off to the left a bit, you just correct it and continue on your way. You don't have to go all the way back to the start.
That's as good a summary on the productivity benefits as you'll see. There's an RSS Feed for Andrew's blog as well
I've been mucking about some more with modules - BottomFeeder now picks up item categories - whether organized under the category tag or under the dc:subject tag. I upgraded the blog feed to included categories, since the blog already has them. Additionally, I made sure to drop accurate item dates - I was dropping the file modification time, not the time of entry for each item.
If you follow the dev versions of BottomFeeder, I have just posted an update to the main application. If you don't see it, change the upgradeURL line to read:
upgradeURL='http://www.cincomsmalltalk.com/BottomFeeder/upgrades/dev/'
After that, you should see the ongoing dev updates. I've started adding module support to the tool - look at feed properties for some of the new information (assuming that the feed you are looking at supports that information, of course). There's a module that gives error reporting information as well - so if you see a problem with a feed, and the feed's author has provided that information, you can send the information directly.
Via Dave Buck I spotted this argument in slashdot. As with most slashdot threads, this one meanders all over the place from a simple beginning:
"Perl programmers like punctuation. Python programmers like indentation. Every programming language has its own syntax, stemming from its philosophy. What I Hate About Your Programming Language examines the issues that shape languages as they grow. It's not advocacy, I promise."
So I had a look at the O'Reilly article that generated this little storm. It's an interesting piece that goes here:
Deciding a language is "good" or not is largely a matter of personal taste. I prefer dynamic typing and don't care much for the strong static typing found in C and its descendants. Part of that is personal taste - it feels like premature optimization to decide that a variable will always fit into eight or 16 bits. (Yes, I know judicious typedefs can lower some of the maintenance costs.) It's also practical; I don't write a lot of code that would benefit from static checking. (A buddy writes drivers at a semiconductor company. Static checking saves him time and effort.)
It's interesting to see just how many people are startingto show respect for dynamic typing - I think this is a large part of why there's a buzz around Python, for instance. It's no longer just us Smalltalk advocates - people who have used little (if any!) Smalltalk are coming to the same conclusions. Here's an interesting thought from that article:
Of course, choosing any one language for a project often means not choosing another language; sometimes that's the most compelling reason. I've had projects where a manager said, "We're going to use language X because that's what VCs expect us to use," where language X was, in my opinion, the wrong choice.Going further, differences in language philosophy present a barrier to learning new languages. This doesn't just apply to existing programmers. It also applies to new programmers - learning to think like a programmer is difficult enough without bothering with syntax issues, editors, compilers, linkers, and distribution
There are way, way too many projects that went to Java for this reason, and I presume that many will go to C# for the same one. I wrote about the insanity of this kind of migration here. To sum it up, if you migrate from X to Y, what actual business value have you gained? The article gives some specific examples of the author's likes and dislikes; I like this example in particular:
It's often used inappropriately. Unless I'm writing a kernel, a device driver, a virtual machine, or an interface to a C or C++ library, writing in C is a probably premature optimization.
Now try explaining that to a long time C hacker though....
The summary is edifying as well:
Over time, my taste in languages has evolved. I used to worry about performance and variable-typing, but working with dynamic (or "agile") languages and learning to love test-driven development has biased me against strong-typing systems. Maybe learning a language like Haskell would balance my thoughtsEvery language is sacred in the eyes of its zealots, but there's bound to be someone out there for whom the language just doesn't feel right. In the open source world, we're fortunate to be able to pick and choose from several high-quality and free and open languages to find what fits our minds the best
There's an interesting response to this article in the O'Reilly thread as well. The poster seems to know Squeak better than most Smalltalks, and conflates some of Squeak's issues with Smalltalk (Namespaces, for instance) - but it's got some good points:
What's not bad about Smalltalk
- Speed. It's actually not that slow. Some tasks under Squeak are faster than Java. Java is faster for others. Cincom's commercial Smalltalk is faster than Java on just about everything.
- multi-person development in an IMAGE based environment. FORTH programmers will known what I'm talking about. Classic Smalltalk stores the complete state of all objects in object memory in an IMAGE. This is basically one big database of objects. For a long time, the big deal with IMAGE based systems was that it was difficult to separate the development environment from the running application. Proper use of changesets and Projects seem to have done a great deal towards fixing this.
Of course, the commercial Smalltalk's all have good source code management support - varying from top notch stuff like Store (VW) and Envy (VA) to interfaces to more conventional (cvs style) systems. Furthermore, you can download just about any vendor Smalltalk implementation for free; check http://www.whysmalltalk.com for links.
|
| Subscribe to WebVelocity |
| Visit this group |