Most Java standards are implemented using an api jar and an concrete implementation jar. The API constists maninly of interfaces but a class that looks up the default implementation. This lookup normally happens by trying to load a specific resource bundle which is located in the implementation jar. This can lead to “interesting” classloader problems when used with OSGi and Spring DM specifically
Read more »
Eclipse Galileo is out a while and it ships with TMF XText 0.7 (formerly openArchitectureWare XText). Amongst other things it contains scoping of references, which I really like and especially the ability to serialize your model back to its text representation without comments being lost.
This is especially convenient if you are currently using some other means of generating code, for example hibernate tools. The serialization feature gives you an easy possibility to transform your existing model to an xtext model from within java code. Even better create updatable models, where you can manually edit the Xtext representation and keep the model up to date from an external source.
Example for loading and saving an XText model:
public static void main(String[] args) {
DomainModelStandaloneSetup.doSetup();
ResourceSet resourceSet = new ResourceSetImpl();
URI uri = URI.createFileURI("myapplication.domainmodel");
Resource resource = resourceSet.getResource(uri, true);
Model model = (Model) resource.getContents().get(0);
Entity entity = DomainModelFactory.eINSTANCE.createEntity();
entity.setName("Customer");
model.getElements().add(entity);
HashMap saveOptions = new HashMap();
saveOptions.put(XtextResource.OPTION_FORMAT, Boolean.TRUE);
resource.save(new FileOutputStream("myapplication.domainmodel"), saveOptions);
}
The classes in bold face are generated from your Xtext grammar.
In a typical spring based server application there is a service layer responsible for infrastructure tasks and communication with the clients. Service methods can be long running and execution would normally block the user-interface. Putting the client side end of the call in a thread solves the blocking but leaves the network connection open while the server side of the call is active. This can lead to all sorts of time-out issues and seems to be the wrong end to fix the problem .
Using spring AOP it is remarkably easy to declaratively enable service methods to execute detached from the regular call context.
@DeferredExecution
public myServiceMethod() throws DeferredExecutionException {
}
This method would execute with the following sematics:
This way clients of this method are forced to handle detached execution (i.e. show a progress dialog querying the server) and the client side of the call not langer lasts longer than a set time.
Read more »
Recently a colleague asked me if model driven software development (MDSD if you like acronyms) is really faster than traditional development. The question is hard to answer because that really depends on the specific set of tools you use, the abilities of your team and so on. Although development time in one of the key arguements for model driven development, the question might be wrongly put. Other factors like software quality and vertical consistency (accross all layers of the application) outweight the time to market argument in my opinion.
Model driven development is often still seen as gray theory by a lot of people but once you experienced it you never want to go back. A lot of the modern web frameworks like ruby on rails, django, cakephp, grails etc. utilize to some extend code-generation methods borrowed from model driven development. Those frameworks are making these techniques more popular and familiar with developers. Stil, those frameworks focus on providing aid for the mundane tasks like generating O/R mappers and scaffolding user interfaces but are not as extensive as a well-tailored model driven development process which goes far beyond just generating certain artefacts.
When doing MDSD you basically have few choices
A) Buy-In: Buy either one of the so called 4GL development environments from another vendor, or buy one toolset of the several CASE-Tool developers (eventually OMG MDA compliant)
B) Roll-your-own: Define your own DSL (domain specific language) for the problem domain and either complety roll your own toolchain (model editor, code generators, validators, …) or use one of the mature open source frameworks like openArchitectureWare or AndroMDA and build on those
Pros
Cons
Pros
Cons
Pros
Cons
Developers are used to working with text files and prefer textual DSLs. Textual DSLs can noadays easily be created using for example the XText project from the openArchitectureWare framework. Business Users are used to graphical languages and prefer those. To satisfy both ends it might be worthwile to have a graphical as well as a textual representation of the model that is fully synchronized.
Model driven development is only faster if applied to a family of software applications. In most cases the first application developed with the new methodology will have a longer time-to-market but developing is a lot more rewarding in terms of quality, consistency and general developer happyness. If done right additional advantages like semantic versioning arise.
How often have you found yourself recording a screencast annoyed by the fact that only the mouse is visible? I haven’t seen any screen recording software that provided an easy way to display shortcuts on screen as you type.
Most of the fancy UI stuff happens in OS X land (see Mouseposé ) but I needed the functionality under Windows. Microsoft introduced the layered window api in Windows 2000 which makes it possible to create alpha-blended windows with any shape.
So on a chilly afternoon I sat down and wrote a litte utility that implements a global key logger which diplays all shortcuts and keystrokes as you type – on screen and with a semi-transparent overlay. This makes it very easy to show any shortcuts you use if you for example record a software demo.
To get a feeling what it looks like: Screencast
Tip: when doing the recording with TechSmith’s Camtasia make sure to enable the “record layered windows” checkbox.
The software is provided AS IS free for private and academic use without any warranty or implied applicability – read the included license in the about box. For commercial use, drop me a line.
System Requirements: Windows 2000 (with GDI+) / Windows XP / Windows Vista
Download: KeyPose Download
Since a lot of People have been asking about a successful integration of digital metaphor’s wonderful Reportbuilder with RemObjects’ DataAbstract I thought it might be a good idea to post what I have been doing to integrate these two in an elegant fashion.
The whole point of a multi-tier setup is to abstract the fact that there is a database from the client, it should not send or know about sql in any case. By allowing the execution of arbitrary SQL by the client you give blank access to all information. To minimise the potential security risk, the associated transaction should be read-only to prevent any updates by the client. Additionally you should specify a security token that is only granted to selected users (“End-User Reporting Allowed”).
Because all data that is being retrieved is re-packaged and transmitted over the wire ultimately ending up in a memory dataset the resulting speed is definitely slower than direct database access and you should likely limit the number of records returned to a reasonable number, so the client does not “hang” while waiting for the whole database to be pulled to local memory.
On the client implement one interface in a singleton (your hydra host would be a good candidate) and assign the global variable in unit daDataAbstract.pas.
{ Implement this interface on the client. Assumptions:
- Single thread on the client (UI)
- One connection to one server
- The Remoteservice.Message.ClientId is implicitly used for session management
set global variable gReportingClientController on the client
}
IReportingClientController = interface
['{9D6908F8-BB64-400F-BE94-0CF550EC2BA2}']
function GetRemoteService: TRORemoteService;
function GetDataStreamer: TDADataStreamer;
end;
This will provide the minimal means to connect to your server
On the server-side you obviously need to implement a service that hosts a TppReport Component and gives necessary information to the client. This service must implement the following interface
{ Implement this interface in the Service that contains the Report component.
When retrieving data on the server, Report.Owner is querie'd for this
interface. Fall-back to local service discovery (FindClassFactory), and
instantiate the reporting service (slower than the former).
}
IReportingServiceRBuilderSupport = interface
['{AFF049E4-5B72-430F-9973-33CF4DC53B6E}']
function GetConnection: IDAConnection;
function GetDataStreamer: TDADataStreamer;
procedure GetTableNames(out TableNames: string);
end;
This interface is used when executing reports “locally” within the server context. The class factory for the reporting service should be a pooled one, since we want to utilize the positive effects of full multi-threading.
The service needs to implement a few additional methods, so the client can gather the necessary information and could look like this
{ TReportingService }
TReportingService = class(TRORemoteDataModule, IReportingService,
IReportingServiceRBuilderSupport
)
BinDataStreamer: TDABinDataStreamer;
bpReportFolders: TDABusinessProcessor;
bpReportItems: TDABusinessProcessor;
ppReport: TppReport;
ppReportItemWithData: TppDBPipeline;
tblReportItemWithData: TDACDSDataTable;
dsReportItemWithData: TDADataSource;
Schema: TDASchema;
procedure RORemoteDataModuleActivate(const aClientID: TGUID;
aSession: TROSession; const aMessage: IROMessage);
procedure RORemoteDataModuleDeactivate(const aClientID: TGUID;
aSession: TROSession);
private
FConnection: IDAConnection;
protected
{ IReportingService methods }
// Needed for report explorer only
function GetAllReportItems: Binary;
function GetReportTemplateData(const ReportItemId: Integer): Binary;
function UpdateReports(const Data: TROBinaryMemoryStream): TROBinaryMemoryStream;
public
constructor Create(AOwner: TComponent); override;
//Called by client-side reporting
function GetReportDatasetData(const SQL: string; const TableName: string;
const LoadAll: Boolean): TROBinaryMemoryStream;
function GetReportDatasetSchema(const SQL: string;
const TableName: string): TROBinaryMemoryStream;
// Only needed if the client should use human readable translated reporting meta-data
function GetDictionaryData: TROBinaryMemoryStream;
// Custom method to execute a certain report on the server-side
function GenerateReportPreview(const ReportItemId: Integer;
const Params: TReportParamList): TROBinaryMemoryStream;
// IReportingServiceRBuilderSupport
function GetConnection: IDAConnection;
function GetDataStreamer: TDADataStreamer;
procedure GetTableNames(out TableNames: string);
end;
The most important part of the implementation is
function TReportingService.GetReportDatasetSchema(const SQL,
TableName: string): TROBinaryMemoryStream;
var
ds: IDADataset;
begin
Result := Binary.Create();
BinDataStreamer.Initialize(Result, aiWrite);
try
if SQL = '' then
ds := FConnection.NewDataset(Format('SELECT * FROM %s WHERE 1 = 0',
[TableName]), 'dsReportData')
else
ds := FConnection.NewDataset(SQL, 'dsReportData');
ds.Prepared := True;
BinDataStreamer.WriteDataset(ds, [woSchema]);
finally
BinDataStreamer.Finalize;
end;
end;
function TReportingService.GetReportDatasetData(const SQL, TableName: string;
const LoadAll: Boolean): TROBinaryMemoryStream;
var
ds: IDADataset;
begin
Result := Binary.Create();
BinDataStreamer.Initialize(Result, aiWrite);
try
if SQL = '' then
ds := FConnection.NewDataset(Format('SELECT * FROM %s WHERE 1 = 0',
[TableName]), 'dsReportData')
else
ds := FConnection.NewDataset(SQL, 'dsReportData');
ds.Open;
if LoadAll then
BinDataStreamer.WriteDataset(ds, [woSchema, woRows], -1)
else
BinDataStreamer.WriteDataset(ds, [woSchema, woRows], 0);
finally
BinDataStreamer.Finalize;
end;
end;
procedure TReportingService.GetTableNames(out TableNames: string);
var
Tables: IROStrings;
begin
FConnection.GetTableNames(Tables);
TableNames := Tables.CommaText;
end;
This article is just a brief overview of what is actually needed to get a fully integrated reporting solution and there are a lot of nuts and bolts involved in the full solution that I will not show here. I hope this solution will help a lot of people who just want to get something working.
Download link: DADE-Plugin for DataAbstract