Curiously during the last couple of days I have received several questions about books and tutorials about Smalltalk. If you are starting with Smalltalk I strongly recommend you to start with “Squeak By Example”, you can download a free .pdf copy from here.
If you need some in Spanish I recommend the book by Diego Goméz Deck, that is available here.
After you had understood the basic concepts I think that two mandatory books are the ones by Adele Goldberg: Smalltalk-80: The Language and its Implementation and Smalltalk-80, The Interactive Programming Environment.
Finally in this page you will get several links to free online books
Hope this help.
Last week I started a development project based on SharePoint 2007 and for the first time for this kind of projects I am using Visual Studio 2008 and the corresponding extensions for SharePoint. Among other things, these extension add some projects templates. Yesterday I noticed that these project templates are class library projects, but with a particular behavior. When you right click on the project file there is a “Deploy” option, witch does not exist in the case of regular class library projects. At first I thought that it was because of some properties in the configuration of the project, but I checked it and there was…nothing. So I opened the project file with a text editor and I noticed that the SharePoint project file had the following additional line:
It seems that this line is the magic item that adds the “Deploy” option in the VS project file menu. I will try to get some more information about this curiosity.
This post wasn’t part of the original series, but I have decided to add it because of a project I am working on these days.
Most of the times I have been involved in the server side of web services, developing web services, but in this opportunity I am consumer of web services.
When reviewing the technical specs of the web services I have to consume I found that each web service returned a complex type that contains the following fields:
- Result: an integer that represents the result of the invocation, (1) successful invocation, (2) Invalid parameters, (3) Internal service error, and so on.
- Errors: in case the result be (2) it details the name of the parameters that are not valid.
- Data: the business information expected as the result of the invocation.
This approach is not bad, but I feel it like been reinventing the wheel. Maybe it is because of my object-oriented programming background. I am used to use exceptions to handle errors. Most of the technologies that give support to soap protocol provides a way to work with exceptions to manage errors.
When you call a web service and an error raises during the process, a soap fault message should be used to communicate the error. This fault message contains:
- Code: that allows the fault to be classified in one of the following categories: VersionMismatch, MustUnderstand, DataEncodingUnknown, Sender and Receiver.
- Reason: provides a human-readable explanation of the fault
- Node: provides information about which SOAP node on the SOAP message path caused the fault to happen
- Role: identifies the role the node was operating in at the point the fault occurred.
- Detail: is intended for carrying application specific error information
No matter what technology you used to work with SOAP, most of them provide a class to represent a Soap Fault, that is typically called Soap Exception. In the case of .NET there is a SoapException. This way if you are using .NET to consume a web service using Soap, .NET will generate a proxy object for you to call the web service, when you call this service you should do it inside a try-catch block adding 2 catch statements one catch for a SoapException and another catch statement for a System.Net.WebException, in case that no connectivity can’t be established.
This is the last part:
Session 4: What should I do with my junior developers?
One of the principles of the agile methods is the self-organized teams, but this is not an easy question when you have junior people in your teams. How much seniority is required to have a self-organized team? How can a person be able to estimate a task that he never performed? How to prevent this inexperienced people to get stuck when working with new things? These were some of the questions that were discussed. In the next few lines I will share the two main ideas I get clear from the session.
1. Don’t let them get stuck
When juniors start a task they may get stucked and there are two bad situations when this occur:
- they start asking all the time, interrupting the work of the rest of the team or
- they try to solve the impediments by themselves and waste too much time
One useful technique to prevent this situations is to use pair programming, making pairs senior-junior but also junior-junior, this last combination gives me great results in my teams. And to complement this it could interesting to make frequent “pings”, I mean every three or four hours just see how they are doing with their tasks.
2. Allow them to choose their tasks
This could sound strange, how can they choose their task when maybe they don’t know how to perform them?. Well the key is how you create the sprint backlog. First of all try to split the work in small tasks, second when the tasks are asigned let the experienced developers to choose first. This way the experienced developers will choose the difficult tasks, and when the juniors have to choose the will have only simple tasks. Another benefit of this approach is that juniors will be able to estimate these simple tasks. Despite of this, it could happen that a junior choose a complex task that you know he don’t have the knowledge to perform it, in that situation make him some questions about how he think he will complete the task in order to make him realize that that task is not the best for him.
That’s all, more after the next Agile Open.
Last Monday, my classmate Maria Florencia Perez finished her studies when she presented her proffesional work: Stima. It is a software that allow users to perform estimations of duration and effort for software development project. It is based on use case points method and it provides some useful features like metrics, estimation history and comparison.
The application is available under Apache License and can be downloaded from Google code rigth at this location.