In the two links that Dare pointed to, I identified three problems with RSS 2.0:
The spec's ambiguous about what can go into <description>, in particular, the practice of putting in escaped HTML is considered a bad idea. Tim Bray endorses either plain text or well formed xhtml; both seem like reasonable options.
The handling of relative URIs needs to be clarified.
It's not clear whether the tag should be used for a permalink or an external link.
When I realized that, I wondered what the controversy was about - it seems like these issues could be ironed out fairly quickly and Echo could get on with putting together a weblogging API.
Dare also mentions politics as being a driver behind Echo. Evidently, this is what the controversy's about. I think that it's a terrible thing to even tacitly admit this sentiment into your mission. I've never yet found software that can fix interpersonal relationships. When all's said and done and Echo is a reality, the same people will still be around, disliking each other.
This is pretty cool - you can now get tips from Microsoft MSDN and from Oracle's TechNet much more easily - look at Oracle's explanation of why they are doing this:
Rather than visiting a series of web sites every day, technologists are installing an RSS-aware news aggregator on their desktop and configuring it to pull RSS news feeds from their favorite web sites. Instead of going to the news, why not have the news come to you!
OTN now offers its own news feed, featuring technical content from the OTN site. Configure your favorite news aggregator to pull OTN's top headlines.
I expect to see companies set up support blogs with RSS feeds, much as they used to set up mailing lists and private news feeds.
Using and Abusing XML and XSL for Smalltalkers - tutorial (extra cost applies)
Joseph Pelrine: Metaprog
Wednesday 8:30:00 am to 12:00:00 pm
Abstract: In the past few years, the Extensible Markup Language (XML) has become much more than just a superset of HTML. By virtue of its level of abstraction and its flexibility, XML can be used to model everything from a simple web page up to a complex data structure. In order for XML documents or data to be displayed to a user in a browser, on a cell phone or as PDF, is it necessary to change the original data into the formats needed for it. As part of the style component of XML, XSLT serves exactly this purpose.
This course illustrates the techniques for changing and transforming data by means of XML and XSLT and points out possibilities for practical application. These technologies and techniques will be shown in the context of Rosetta, a dialect-independent framework for Smalltalk code exchange.
Bio: Joseph Pelrine is C*O of MetaProg, a company devoted to increasing the quality of software and its development process. He has had a successful career as software developer, project manager and consultant, and has spoken about it at such diverse places as IBM, OOPSLA and the Chaos Computer Club. Having survived working with Kent Beck, he currently works with Dave Simmons on and in SmallScript when he's not helping his clients solve their problems.
Reverse Engineering may be something that can be specifically forbidden by a EULA - depending on how the ruling ends up getting applied. Potentially scary.
Before Sun sued Microsoft, they didn't even have a Washington office for lobbying. Having learned that was a bad idea, we now have MS doing this - pushing for more regulation of the cable industry. I liked it better when MS didn't have a Washington office.
I was adding cookie support to BottomFeeder this morning - and that got me into the http access code. I hadn't looked at it in awhile, refactored some ugliness, and came across some interesting bugs. What you may have noticed with the dev builds is this - some feeds were not getting updated unless you forced an update. This had to do with the way I was doing conditional-get - that relies on there being a few pieces of information from the server to cache, and I wasn't always checking to make sure that I actually got them. When I didn't, I tried filling in the request header anyway, and that created an exception - which gets swallowed, since network accesses cause lots of interesting exceptions, and end users really shouldn't see most of them.
Anyway, that's fixed, and a few feeds that were not updating for me are doing so now - I guess I track too many feeds (142 at the moment) if I hadn't noticed....
The VisualWorks 7.x HTTP code does not have explicit support for HTTP Cookies. This is on the list of things to be addressed - although possibly not by 7.2. At the moment, SOAP Header support is a more difficult problem, and is being dealt with. So in the meantime, what if your application needs to deal with Cookies? Well, adding support isn't terribly hard. I've published a package (used by BottomFeeder) called Http-Access in the public store that - among other things - has support for reading cookies, caching them, and sending them back with requests. Here are the basic steps I took:
First, I added two methods to Net.Response:
getCookies
"Returns all Cookies"
| cookies |
cookies := self fieldsAt: 'set-cookie'.
^cookies collect: [:each | VisualWave.HTTPCookie readFromHeader: each]
There's already a cookie class available, as part of VisualWave. Instead of cloning that into the Net namespace, I just used it. I also wanted to be able to look for cookies by name:
getCookieNamed: aString
^self getCookies detect: [:each | each name asLowercase = aString asLowercase] ifNone: [nil]
There's one more method required - the one I added to VisualWave.Cookie for decoding the cookie from a response. The class doesn't know how to do that, as it was built with the (slightly different) VisualWave framework in mind. Over the next couple of releases, that kind of overlap will disappear, btw. in any event, here's the code that reifies a cooki object:
readFromHeader: cookieAsHeader
| stream |
stream := cookieAsHeader value readStream.
self name: (stream upTo: $=).
self value: (stream upTo: $;).
[stream atEnd]
whileFalse: [| next msg val |
next := (stream upTo: $=) trimBlanks asLowercase.
stream atEnd
ifFalse: [msg := (next, ':') asSymbol.
val := stream upTo: $;.
[self perform: msg with: val]
on: MessageNotUnderstood
do: [:ex | ex resume]]].
That handles grabbing the cookies. In my package, I stuff them into a cache object (which I use for conditional-get). Now I have cookies; how do I send them back in a request? I added these two methods to Net.Request:
addCookies: cookies
cookies do: [:each | self addCookie: each]
And that's pretty much it. Your application code needs to actually deal with the cookies in a reasonable way; this code just shows how to grab and send them. Comments or fixes? Send them here
It's not the syntax - which is why an edit/compile/link Smalltalk would be so pointless. Clarence Westberg gets it:
I don't really see the point to coming up with smalltalk environments that put you back in the Visual Studio mode. Converting smalltalk to C# might make sense in some porting sense but not in any real development sense. The same is true for the S# work I have seen so far. I mean the real attractivness of smalltalk is the smalltalk "world" not the syntax. People don't get that, syntax is something any programmer can pick up in a few days but the smalltalk "world" is truly unique and extremely productive compared to the edit-complie-link world of the {} world.
I went into BottomFeeder to add cookie support earlier, and ended up addressing a host of other small issues - including proper handling of 301 (link moved) errors. i've got a new dev parcel up.
HREF Considered Harmful: Structured Web Development with Seaside
tutorial (extra cost applies)
Avi Bryant and Julian Fitzell: beta4.com
Monday 2:00:00 pm to 5:30:00 pm
Abstract: Dijkstra may have taught us 45 years ago that GOTO was a bad idea, but web development has barely caught up. In the CGI model of web applications, each link that is followed triggers an entirely new execution of the program. Building complex control flow out of these abrupt transitions can lead to a tangled and brittle mess of interdependent pages. Modern frameworks such as WebObjects and Struts may remove many of the difficulties of CGI scripting, but they do not escape the web's inherent GOTO: moving from one page to the next, whether through anchors, actions, forms, or forwards, is still a simple one-way jump.
Seaside is a framework for developing web-based applications that insulates the developer from the HTTP request/response loop, presenting the illusion of a continuous interactive session with the user. Each page or form acts much like a subroutine, which returns a value to its caller based on user input. Complex, conditional or looping workflows can be described in a single piece of straightforward Smalltalk code as a sequence of calls to individual pages. The benefits this brings to the reusability and maintainability of web applications closely mimick the advances made by structured programming long ago.
Seaside also sports callback-based form widgets (no manual request processing), transparent embedding of pages or even whole applications, a library of prebuilt components, and a complete web-based development environment, with code browsers, inspectors, debuggers, and profilers, all implemented in Seaside itself.
During this half day workshop, participants will be guided through building a simple business application with Seaside. Along with coverage of framework basics, special attention will be given to three topics: writing cleanly reusable pages and components, separating page logic (how an individual interaction works) from application logic (how interactions are strung together to form workflows), and proper management and support of the all-important browser back button.
Bio: Avi Bryant provides Smalltalk consulting and development services in Vancouver, Canada.
Julian Fitzell is a senior developer in the Agile Projects Group at the University of British Columbia.
There's a new book based on VisualWorks 7.1 being published in Germany. The Cincom Smalltalk NC CD will be included with the book; I'll post more details on this when I have them.
The title is "Grundkurs Smalltalk - Objektorientierung von Anfang
an. Eine Einfuehrung in die Programmierung" - which translates to- "Smalltalk 101 -
OO from the beginning. An introduction to programming"
350 pages, should be available in September 2003 - Author is Johannes Brauer.
As a result of my struggles with SOAP & WSDL in Java, C# and VW I put together a short tutorial on creating SOAP servers and clients in VW 7.1. It contains several complete examples and has been used locally. The tutorial is available here.
O/R Mapping in Smalltalk
presentation
Alan Knight: Cincom
Wednesday 2:00:00 pm to 3:30:00 pm
Abstract: Few areas arouse as many different opinions as storing objects in relational database. There are some fundamental issues in doing this efficiently. Also, we often don't have the luxury of designing our own schema, but have to deal with one that does not correspond well to our object model. This presentation outlines some of these problems and the way they are addressed in the open-source GLORP framework (http://www.glorp.org), as well as how we plan to move forward on database mapping software in future releases of VisualWorks.
Bio: Alan Knight is a senior developer with Cincom Systems, where he is involved with web application development and database mapping. Before joining Cincom he was with The Object People, where he served in a variety of roles, most recently chief architect for the TOPLink family of Object-Relational Mapping products, both Smalltalk and Java. He is a former member of the Sun JSR committees for JDO and EJB 2.0, co-author of the book Mastering ENVY/Developer, a former columnist for The Smalltalk Report, and a frequent speaker at a variety of conferences. He is also program chair of Smalltalk Solutions 2003.
I've been doing a lot of work on the HTTP access layer of BottomFeeder - it turned out that the exception handling code had some issues, and that was causing reading problems for a variety of feeds. I went through the issues carefully over the last couple of days, and it all seems cool now. The doc is updated, the application now handles all the major RSS modules - so I think it's ready to go live. I'll be uploading files and updating the html site files for awhile - I'll make an announcement later when all that's done - including updating SourceForge and Freshmeat.
I've released BottomFeeder 3.0. The site is updated, the upgrade files are all up to date, and the new documentation is online. Enjoy! For some details on the new features, visit this wiki page
I've been annoyed whenever I've received an email that asks me to verify that I'm not a bot by visiting a site and clicking a fuzzy image. It turns out that some people may be hosed by these schemes:
Many companies have recently begun requiring users to pass a verification test in order to access their services--typically by typing into a Web form a few characters that appear on the form in a guise that prevents a computer or software robot from recognizing and copying them. The technique, now used by Web giants Yahoo, Microsoft, VeriSign and others, seeks to block software bots from signing up for Web-based e-mail accounts that can be used to launch spam and from scraping e-mail addresses from online databases.
The scheme is winning high marks in the battle against unwanted junk e-mail. But it is also increasingly hindering the progress of Web surfers with visual disabilities--raising the ire of advocates for the blind, spurring plans for alternatives from a key Web standards group, and eliciting warnings from legal experts who say that the practice could expose companies to lawsuits brought under the Americans with Disabilities Act.
So it's not only irritating - it may well be a total block to the blind and visually impaired.
Via Scott Knowles comes this survey showing that people hate pop ups - but advertisers benefit from pop ups more than from other online ad styles. Do marketing folks have to wonder why it is thatdistrust keeps growing? Mind you, i'm in marketing now - so this is a personal issue now....
The Ottawa STUG has an interesting talk scheduled for tomorrow evening:
A new MacOS X Smalltalk
Dorin Sandu, Mark Suska
Ambrai.com
Date: Thursday, July 3, 2003
Time: 6:30 PM
Location: Carleton University (see details below)
We will introduce a brand new Smalltalk system that runs natively under MacOS X. After a tour of the development environment, we will cover the design and implementation of the user interface framework including the native interface to the OS. Time permitting, we will review VM design issues and discuss future development plans.
The meeting will be held in Room 5115, Herzberg Laboratories - building 13 on the map. Pay-parking is available in Lot 1, 2, and parking meters can be found along University Drive. Free parking is available across Bronson Avenue opposite Lot 5.
Cincinnati (where Cincom and this server are located) had some t-storms rumble through, and there was a power outage. There was a bit of confusion as to how much time was left on the battery backup, so the server was taken down as a precaution. We were out for less than five minutes - but that killed a 200 day uptime - which went back to the installation of the box this is on. Oh well...
Black Knight: Eclipse as a Smalltalk Development Environment
presentation
John O'Keefe and Eric Clayberg: IBM, Instantiations
Monday 2:00:00 pm to 3:30:00 pm
Abstract: Smalltalk is arguably the world's most productive programming language. Eclipse is quickly approaching being the world's best development framework -- "an open extensible IDE for anything and nothing in particular". Black Knight represents the marriage of these two premier technologies. It provides a set of Smalltalk Development Tools that bring the best features of existing Smalltalk IDE's into the Eclipse world, an extensible Smalltalk class library based on the VisualAge Smalltalk Enterprise code, and an executable runtime for applications developed in Smalltalk. Black Knight is an Eclipse Technology Subproject.
Bio: John O'Keefe has been doing software development since it was done with wires and patch-panels. He has been on the VisualAge Smalltalk team since 1992 and has been the Team Lead for the last 7 years. Most recently he has formed the Black Knight team to produce a new cross-dialect Smalltalk IDE.
The project name shows they have a sense of humor :)
I'm not making a particularly controversial (or new) statement when I say that when developing some project, having the development team "eat their own dogfood" is a very useful technique. If you are writing an email application, have the developers adopt it for their email. If you are writing an IDE, have the developers use the IDE to write its own next version. Nothing focuses a developer more than the desire to fix something that's annoying them personally.
True, very true. But it's also the case that you need other people eating your dogfood, or else you end up with tools thata suit you and no one else:
There's a flip-side, of course. One example of this is JBoss, and its mass of thinly documented XML configuration files. Of course the developers know exactly how they work. They know where to find everything so they don't find the complexity annoying4. Find that a problem? It's Open Source and you can fix it yourself. However, by the time you know enough about a product to fix a problem like this yourself, you know enough not to be experiencing the problem any more. Hence it falls down the back of your priority list. Catch-22.
I've come across this in BottomFeeder - there's nothing like having other people point out interesting aspects of your software to keep you on your toes. It's all too easy to end up with stuff you (and only you) can use. Go read the whole thing
AOStA An Adaptive Optimizing Smalltalk Architecture
presentation
Eliot Miranda: Cincom
Tuesday 2:00:00 pm to 3:30:00 pm
Abstract: AOStA is a portable architecture for adaptive optimization in the context of existing Smalltalk virtual machines. The adaptive optimizer is a bytecode-to-bytecode optimizing and inlining compiler. It is written in Smalltalk, runs in the image, and in a meaningful way is portable across dialects. It runs above a JIT virtual machine with minimal extensions to allow introspection on in-line cache information, to provide simplified "go-faster" versions of certain primitives, and to callback into Smalltalk from "hot spots".
Bio: Eliot Miranda is technical lead for VisualWorks, the direct commercial descendent of Xerox Smalltalk-80, at Cincom Systems, Inc. Eliot has been working on Smalltalk VMs since 1983. Eliot got his degree in Computer Science at the University of York before becoming a research assistant and lecturer at the University of London. During this period he designed and implemented the BrouHaHa bytecode and threaded code VMs which achieved a good compromise of performance and portability through innovative C compiler abuse. After a brief digression collaborating on the Harlequin Dylan implementation, designing the stream and pickling systems he joined ParcPlace Systems in 1995. He designed VisualWorks' threaded interconnect, the programmer-productivity features of the parcel component system and significant performance improvements to the VM, all within the context of a merger, three name changes and a purchase by Cincom in 1999, and can say with some relief that the system is still commercially viable. Eliot has been a member of the ACM since 1988.
Tokyo - Japanese publishers said on Monday they will launch a campaign this week to stop digital shoplifters - people who visit bookstores to photograph magazine pages with their cellphones rather than make a purchase.
Digital shoplifting is becoming a big problem as camera-equipped mobile handsets are spreading fast and their quality is improving greatly, said Kenji Takahashi, an official at the Japan Magazine Publishers Association.
Starting on Tuesday, bookstores across the nation will put up posters urging magazine readers to "refrain from recording information with camera-mounted cellphones and other devices".
That's just fascinating. And I just about died laughing when I saw this line in the story:
The latest advertisement by the association, published in newspapers on Sunday, urged users not to write emails while walking.
Researchers at the University at Buffalo, New York, announced last week they have developed a system that lets one person experience the sense of touch felt by another. They said they could transmit the sensation across the Internet.
Here's a solid prediction - the porn industry will be the first to figure out how to make money from this. Which means that you reall will have to wonder where that keyboard has been....
One of the Java Bloggers (Daniel Steinberg) talks about leaky abstractions. Joel on Software wrote on this last year (and why doesn't this guy link to it, since he mentions it?) - then he lets loose with this:
To make code more performant, you generally have to make it less readable. Readability often involves introducing abstractions. You don't talk directly to your data base, you use JDBC. You don't follow pointers to find the next element in a collection, you ask the corresponding Iterator to return next(). The problem with this, according to Joel Spolsky, is that all abstractions leak. Today in Java Today Craig Castelaz discusses this balance in "Living with Leaks". Craig looks at Spolsky's Law of Leaky Abstractions and Keppler's continuum of abstractions that predates Spolsky's work by a decade.
Hmm. Maybe It's that I use better tools, but I find just the opposite. cleaning code up and making the intentions clearer typically lead me to faster code. I consider this whole idea of "nasty code is faster" to be a hoary old chestnut that needs retiring, fast. Referencing the Cringely article (and why doesn't he link to it?) shows a high level of cluelessness. If he thinks refactoring is useless, he shouldn't be writing code, period.
I've noticed two trends that seem to be accelerating in the Java (and C# - generally speaking, the C language family) world:
An increase in the number of configuration files - typically XML - that things have
An increase in the amount of code generation - both the amount being done, and the amount being advocated.
Apparently, code is so incredibly hard to produce in the C world, that it's simpler to create a huge morass of configuration files - and generate a ton of code. Somehow, I have a hard time thinking of this as progress. Here's a comment on this trend by Charles Miller:
One example of this is JBoss, and its mass of thinly documented XML configuration files. Of course the developers know exactly how they work. They know where to find everything so they don't find the complexity annoying4. Find that a problem? It's Open Source and you can fix it yourself. However, by the time you know enough about a product to fix a problem like this yourself, you know enough not to be experiencing the problem any more. Hence it falls down the back of your priority list. Catch-22.
Patrick Logan linked to an interesting article that's ostensibly on XML-RPC, but contains the following quote: "Python is one of the more popular languages for XML-RPC apps, because it has a very flexible way of creating remote procedure calls that look much like local ones." To me, this is interesting in that it highlights how people like to write code. First of all, there's the question of whether I even want to write RPCs. Then, there's the issue of programming language design. I feel like XML-RPC and SOAP were designed with curly-brace programmers in mind, where there's all this effort to generate proxies that look like LPCs, but totally ignore support for message style communications.
That's dynamic typing in action. I was doing CORBA with VisualWorks years ago - and while all the C/C++/Java guys complained about how complex it all was, I always found it to be pretty easy. Now, there's complexity to RPC development - checking for failure is never an entirely simple operation. However, there's all this extra baggage over in curly brace land. This goes back to the code generation thing - part of why the curly brace crowd is enamored of code generation is that they have to be - no person could stay sane and have to write all that proxy code....
Test-Driven Development
tutorial (extra cost applies)
Dave Astels: Adaption Software, Inc.
Wednesday 2:00:00 pm to 5:30:00 pm
Abstract: This will be a very pragmatic tutorial, with a mix of lecture, demonstration, and hands-on exercises. Background, tools, and techniques of TDD would be covered, as well conceptual topics such as refactoring tests, building tests around fixtures, what makes for a good test, approaches to writing tests to maximize the benefit, etc. Hands-on means programming, so make sure to bring a laptop and be prepared to pair-up.
Bio: I've been programming is some fashion/capacity for over 20 years, over 12 of that using OO. I learned OO from Smalltalk and have at least 6 years of Smalltalk experience, in areas ranging from a mass-market, shrink-wrapped CDROM series of products to natural language processing and acquisition reasearch.
I am a founding partner of Adaption Software, based in Wolfville, Nova Scotia (home of Acadia University and Ivan Tomek). I have coauthored one book: "A Practical Guide to eXtreme Programming", and have just finished writing another: "Test-driven Development: A Practical Guide". Both titles are published by Prentice Hall.
I've recently taken over the Smalltalk port of Ward Cunningham's Fit framework (from Ward, John Brant and Don Roberts).
Sunshine, but not unbearable, a nice parade - my daughter, as usual, was in it, and grilled steak for dinner. If the T-storms stay away, we'll probably head over to to Columbia fireworks display. Happy 4th everyone!
I was pointed to this interesting article by Roger Whitney. It's a lessons learned paper dealing with Open Source development. There's a bunch of good stuff on things you ought to know about OS projects before you jump in - here's the most interesting (to me, at least) bit:
Engineering Lessons
C/C++ is no longer a viable development language. This may seem obvious to some people, and other people may recoil in shock. In college/grad school we were taught to believe that C/C++/Java, etc are the best languages in the world, so it was a very difficult transformation to accept that these languages are not viable development languages for application level work.
C++ is seen to be great for execution speed, static binding, object orientation, templates, and more. However, it is absolutely lousy for development time. Here's why:
It requires compilation " as your code grows larger, the wait time to see if your code works increases. This delay directly affects how fast your code is developed.
It's really, really, really hard for people to learn it, and this directly impacts the number of developers you will have on an open-source project.
It uses static binding (Isn't that supposed to be a good thing?)
There are no standard libraries for C++, so there's a lot of reinventing the wheel. (Yeah, there's the STL and others, but each one has a huge learning curve associated with it).
Java somewhat fixes the learning curve and the standard library problem, but still has the other two problems, and in addition requires the user to download the JRE before you can run any java program (a 25 MB separate install). One of my previous jobs had us trying to deploy a client-side Java program to much failure because of this hurdle. Server-side programming doesn't have this problem so Java may not be such a bad choice for that.
if you want to get somewhere in a reasonable time period, pick a dynamic language. If you're going to do that, look at Smalltalk.
If you had autho-browse empty descriptions turned on, you got an error. I fixed this in the 8.101 version of the code
Some feeds use GUID instead of link - no good reason for that, but there are politics surrounding RSS. In any case, Bf now uses the GUID if the link is missing, and the GUID is an URL
What's nice about the update feature is that I don't have to manage farms of patches or rush a new version out - I can just have the application offer to upgrade itself.
Bob Werken posted about PapersInvited.com, the Largest listing of call for papers in all areas of specialization.
This whole area would be a great application RSS. You could have RSS feeds for researchs in particular feeds. Those RSS feeds could be driven off the RSS feeds from the program committee chairs. The feeds could help with all the logistical announcements that go along with announcing a call for papers, reminding people that the call is going to expire, announcing the program, announcing the arrangements, and making announcements about the conferences.
Actually, I'm surprised that O'Reilly isn't trying to do something like this with an RSS feed for their conferences. I know I'd subscribe to a feed for OSCON and ETCON...
I have much the same feeling. The one thing that I wish was different was performance. I know that Python is supposed to be for gluing C apps together, but I just did a little hacking on Kai Hendry's LuPy version of my Lucene plugin for pyblosxom, and it wasn't pretty. I wasn't sure that LuPy was reading the Lucene index files right, so I decided to reindex using a LuPy based indexer. Talk about slow.
I find this all kind of frustrating. I can say that I am vastly more productive in VisualWorks now than I was a few years ago - the tools are better, the language is better. Performance is much better - and you should see this talk at StS for info on how it's goiig to get better still. Smalltalk has evolved quite nicely, thank you very much - and I'm sure that the various Lisp tools have as well, although I have no real experience with them. There's actually fairly vigorous competition in the Smalltalk space, because we have multiple vendors - we get various takes on what works and what doesn't, instead of what Sun knows is best or what Microsoft knows is best. Why is Eclipse boring? Perhaps it's because - unlike Smalltalk and Lisp - it takes no advantage of being written in itself. You can't modify the environment, or even ask intelligent questions of it. Being able to do so is what leads to productive tools. Python doesn't quite get there, because - as a scripting language - people tend to use things like vi and emacs to develop. Productivity simply does not lie that way.
So what is this collective blind spot in the developer universe? Is it the siren song of Open Source and free tools? Are developers thinking that if its not free, they won't use it? That's part of it, I'm sure. And it's an interesting problem. certainly those same developers don't want to work for free - they want to be paid like everyone else. This leads to this theory: You should make money from consulting, not from the tools. To which I respond: Why?. You do realize that under that theory, small shops are pretty much locked right out? You need a certain scale in order to have a bunch of developers and a bunch of consultants. And before you say that the developers should be the consultants - not every developer is really suited to a customer facing position. Does the developer community really want to write off all the potential tool builders who are unwilling or unable to be consultants at the same time? Apparently so.
I think a lot of developers need to wake up and realize that "free" tools largely means bland, corporate tools - and bland, corporate languages. It takes a large outfit to be able to treat tools as loss leaders - leaving little room for small to mid-size outfits that might want to concentrate on different approaches. Even in curly brace land, all the interesting tools have been acquired (and then mostly disappeared). People seem to recognize that you get what you pay for - right up to the point where they select development tools. Then they expect a handout. If we stay on this path, we'll keep right on down the road described by Larry O'Brien.
I sat down this morning and added support for the necho Format. It only took a few to add it - it's nearly identical (with different tag names to confuse things) to RSS. The current dev build - change your upgrade path to /dev at the end - will handle the new format. Thus far I'm ignoring the contributor tag, but I'll get around to that eventually.
As I said earlier, you get a much more engaging experience if your objects are tangible and manipulable. The traditional presentation of source code as plain old text might be familiar, but it's hardly earth-shattering. Squeak has alternative ("tiles") rendering mode for source code which displays the structure geometrically. When you realise that the contents of your ASCII text file is just one particular representation of the "Platonic Ideal" version of your code, you start wonder if it's a good representation, or if it's a load of rubbish.
One of the things Store doesn't have is support for versioning external files. That's coming, but in the meantime, David Pennell of Quallaby has placed a File Repository package into the public Store. Here's what he says about it:
You might want to take a look at the FileRepository package that I just published in the public repository. I think you have something similar on the VW futures list - this seems like it might be useful for maintaining ASP/JSP pages.
From the package comment:
This package allows you to place text files under VW's source control. Create a subclass of FileRepository and add methods containing a <file:'filename'> pragma.
Refactoring Browser buttons are provided for comparing the internal and external version of files, updating the internal or external file and launching the Differator. Browsing a file method will automatically compare the internal and external file.
You must close and re-open Refactoring Browser's in order for the extensions be activated. Internal files are not stored in the image, but are stored in the change
file. Adding a post load action to a StORE package of the form: [:package | MyFileRepository updateAllInternalToExternal ] will cause external files to be created or updated if necessary when a package is loaded.
I've not been terribly enthusiastic about the echo effort. however, it does look like it's picking up steam, and it will likely evolve into something useful. So, the dev builds of BottomFeeder now support feeds in this format. Also, I've added an necho feed for this blog and for the comments. Thus far, the format is less useful (IMHO) than RSS 2.0 with modules, but it looks like something I need to support.
But to blithely assume that we can load developers with endless unfunded mandates (lots of the echo people want every weblog tool to support three different echo api's, in addition to blogger and metaweblog) and not have everything blow up.
Essentially all the professionals in this space -- people who go to work every day to build shipping products that use RSS -- are feeling queasy about nEcho. Everyone is on board -- and I think everyone is worried
Today's Spotlight is on David Simmons and Joseph Pelrine's S# tutorial. While I'm personally skeptical about some of the language mods Dave has made, it's clear that S# is raising the profile of Smalltalk:
Delivering Smalltalk natively on .NET with S#.NET and S#.AOS and Competing on a level playing field
tutorial (extra cost applies)
David Simmons and Joseph Pelrine: Smallscript, MetaProg
Tuesday 2:00:00 pm to 5:30:00 pm
Abstract: This tutorial will present the working S#.NET and S#.AOS system toolset and language. Attendees will learn how to write secure, verifiable applications, components, and frameworks in Smalltalk that deploy natively on .NET.
Special focus will be given to both business and technical aspects of creating libraries in Smalltalk that can be consumed and/or sold for standard use and consumption by any other .NET language. If you want options for being able to write code in Smalltalk while conforming to mainstream demands for .NET interop compliance and compatibility with languages like C# and VB then this tutorial is for you.
S# is a modular superset of the Smalltalk-98 language offering a rich, generalized, object model for dynamic languages on both its own native SmallScript AOS platform and the Microsoft .NET Platforms.
Bio: David Simmons has been designing and developing language systems and virtual machines for since the early 1980's. He was the principal designer and architect for commercial toolset within QKS Smalltalk-91 and its multi-language, multi-threaded execution engine. His most recent work has been the design and development of S# within the SmallScript Language System, a modular multi-threaded platform for dynamic languages. His design work has focused heavily on complexity management, portability, modularity, performance, object models, and meta-object protocol capabilities for supporting a superset of today's popular programming language features.
My take is that this is fiction, but hey - decide for yourself. Via the .NET guy:
Someone anonymous posted to the Joel on Software message board about having their software protection cracked in just 3 days. Yeah, typical, but the real interesting one was this anonymous response:
We have a full time employee whose sole job is to be involved in the cracker community. He has high prestige because he has been first out the gate with several high profile cracks -- all of our own software of course. Because he is actively involved in producing high profile, high quality cracks, he has also acquired the personal contact info regarding a large number of other crackers. We maintain a mailing address for him near a foreign branch office to cover his own tracks.
This provides us with a couple of advantages: our cracked software contains a trojan that not only logs information about the users computer, but also scans their system for other cracks. This information is transmitted back to us and we share it with a few other companies that use this system. The information is stored in a database where it is made available to the FBI for use in their own investigations.
