• Home
  • Events
  • About
  • TSSJS 2009: JavaFX in Action (my session!)

    October 29th, 2009

    Today I gave another talk on JavaFX. Since this was TheServerSide I assumed no knowledge at all of the client-focussed technology. Once again, my approach was to take the audience with me on a trip along JavaFX’s (short) time-line, since it’s first introduction in 2007. In doing I attempted to show/describe:

    – What JavaFX does (UI, graphics, multi-media)
    – The tools we use (Adobe, Netbeans)
    – JavaFX Mobile
    – The importance of threading awareness
    – The future (JavaTV, 3D, improved support for widgets, layout management)

    .

    L1030444

    Mike Mannion in Action

    .

    I didn’t hold back with regard to some concerns I still have about with JavaFX technology, which some members of the audience may have found a little surprising. But still I hope the attendees will have got a glimpse at the power and potential of JavaFX, and what it may mean for the future of Java on client devices.

    To finish up, the Prague audience posed some excellent questions, which I did my best to answer.

    Download my slides here. And if you’ve got any questions feel free to mail me at mike.mannion@canoo.com

    So that was that for my first TSSJS for me, as I had to catch a plane back home…

    My thanks to all the contributors – especially to TSS editor Peter Varhol and to Karen Travelo – for putting this excellent conference together!

    Share and Enjoy: These icons link to social bookmarking sites where readers can share and discover new web pages.
    • email
    • Print
    • Twitter
    • LinkedIn
    • XING
    • Facebook
    • Google Bookmarks

    TSSJS 2009: Every Day Static Code Analysis

    October 27th, 2009

    Speaker: Václav Pech, JetBrains (makers of the IntelliJ IDEA IDE)

    Václav begins by citing author of findBugs tool bug categories.

    He goes on to presents some nice examples of each of these bug types. Then shows Intellij plugin for static code analysis with on both demand and on-the-fly analysis (very comfortable for the developer).

    Adding bug detection to the tool means specifing an undesirable pattern in the program’s AST. Speaker demonstrates creation of a new rule using „PMD rule designer“.

    After naming three of the most popular tools (findBugs, CheckStyle, PMD), Václav demonstrates the use of these tools in NetBeans. The SQE plugin integrates the above tools into a unified view. Nice.

    Then, just to prove he’s not all about IntelliJ, he shows FindBugs and PMD in Eclipse.

    Now back to IDEA again: We see a powerful code analysis and quick-fix tools in IDEA, as well as the ability to define new tools.

    Next up: New JetBrains language-aware annotations, which can also provide language-specific code completion in cases where SQL, CSS or any variety of languages are held in a Java string. Very nice, although limited to Strings as opposed to derivations of CharSequence (StringBuffer, StringBuilder).

    Václav’s slides are available here.

    Summary: This talk presented a useful overview of static cod analysis tools. A sales pitch for IntelliJ? To some extent, perhaps. But having used NetBeans, Eclipse AND IntelliJ in the past twelve months, I can testify to IDEA’s superior support wen it comes to code analysis (as well as other things.) And no, I am not being paid to write this.

    Share and Enjoy: These icons link to social bookmarking sites where readers can share and discover new web pages.
    • email
    • Print
    • Twitter
    • LinkedIn
    • XING
    • Facebook
    • Google Bookmarks

    TSSJS 2009: No More Loops with LambdaJ

    October 27th, 2009

    Speaker: Mario Fusco, LambdaJ creator

    What makes me think this talk is going to have something do to with the lambda calculus, a subject I recall enjoying greatly during my Comp-Sci degree?

    So… the heavily accented Mario describes the motivation for creating LambdaJ: To create a way to select beans of particular properties without all the hassle of loops i.e. iterating.

    The result: A DSL to manipulate collections in pseudo-functional, statically-typed way.

    LambdaJ comprises 2 main features: forEach and sort. Each of these methods are importable via static import.

    The result is a compact was to express collections-based operations as a single line of code as opposed to using a sometimes complex loop, locally declared variables etc.

    Mario shows several examples, which make this compactness quite clear.

    However, he goes on to points out that LabmdaJ five times slower (average) than pure Java with his examples. Performance takes a because of all the reflection that goes on. However, he performance hit thinks this is unlikely to prove to be the bottleneck in practice.

    Some other limitations:
    • Cannot infer type to be returned because collection class parameter is not reified at runtime.
    • Cannot use with final classes because cannot create dynamic proxy for final class.

    The LambdaJ project is open-source and is hosted at Google Code.

    Question raised: Why not use hibernate criteria query API? Mario: Yes, can use this.
    LambdaJ is typically used in business layer after data has been fetched from DB (e.g. via hibernate.)

    Presumably, then – for LambdaJ to be worth while to use in practice – you need to have a situation where multiple evaluations are performed against a previously fetched result set. This would then (potentially) save multiple fetches against the DB, depending on the queries involved.

    Mario’s slides, which show plenty of code-samples, are available here.

    Summary: I sense a slight buzz of skepticism emanating from the audience and my feeling is reenforced when very few questions are posed. Whilst LambdaJ code is significantly less verbose than its Java equivalent, I suspect the situations in which it could be used are relatively few in number.

    Oh: And I was totally off about LambdaJ being in someway related to the Lambda Calculus. Neither have loops, that’s true, but the commonality ends there.

    Share and Enjoy: These icons link to social bookmarking sites where readers can share and discover new web pages.
    • email
    • Print
    • Twitter
    • LinkedIn
    • XING
    • Facebook
    • Google Bookmarks

    TSSJS 2009: Rapid Dynamic Modular Application Development with Impala

    October 27th, 2009

    Full title of talk: Rapid Dynamic Modular Application Development with Impala, the Simple Approach to Dynamic Modules with Spring

    Speaker: Phil Zoio, Impala creator

    Phil begins by highlighting a major weakness of basic Spring: The single address-space available to all the beans, which becomes increasingly unwieldy as number of classes/beans increase. Impala enables the developer to group beans into logical modules, which can be subsequently swapped out dynamically.

    Phil goes on to demo runtime-changes to a spring config as well as a bean implementation class, which result in Impala automatically re-loading the modules concerned. This is achieved by breaking the static (compile-time) coupling between client and implementation code.

    Phil now shows a neat little interactive test runner, which I assume is part of the Impala package. One of the commands enables the user to explicitly reload a particular module, which is obviously more efficient than reloading the entire app. Using this in conjunction with the dynamic replacement of code results in extremely fast test/fix-roundtrips.

    Phil now talks about the difference between the Impala and OSGi approaches. No third-party library versioning with Impala – in contrast to OSGi. OSGi, however, is more complex was never conceived for large enterprise systems.

    Phil’s slides are available here.

    Summary: An informative even if (again) somewhat dry talk about a potentially interesting tool. Of course, one can’t judge the effectiveness of the tool on the basis of a single presentation, especially when it comes from the tool’s inventor.

    One final thing: Phil didn’t mention JSR294. Methinks the discussions on how to best modularise Java are going to persist a while…

    Share and Enjoy: These icons link to social bookmarking sites where readers can share and discover new web pages.
    • email
    • Print
    • Twitter
    • LinkedIn
    • XING
    • Facebook
    • Google Bookmarks

    TSSJS 2009: Real Life Java EE Performance

    October 27th, 2009

    Speaker: Matt Brasier, Principal Consulting LTD
    Speaker/company background: Non-functional requirements.

    Matt’s philosophy:
    • Good understanding is the best performance/tuning tool
    • Common & open source tools
    • Observe, hypothesize, tweak, test
    • Trust no-one

    He goes on to describe three case studies, which demonstrate how he puts this philosophy in practice.

    Matt’s slides (which also outline the case studies) are available here.

    The key message for me is the application of systematic analysis, hypothesis formulation and testing. This can, in fact, be described as a scientific approach, which gets a big thumbs up from me.

    A second key message was the high value of a centralized repository of problems/solutions. This is apparently what Matt’s company has set up, and the repository now represents significant intellectual capital for the company.

    Summary: I found Matt’s didactic style a tad dry and bullet-pointy; but all in all the substance made up for this and for that the talk was indeed worthwhile.

    Share and Enjoy: These icons link to social bookmarking sites where readers can share and discover new web pages.
    • email
    • Print
    • Twitter
    • LinkedIn
    • XING
    • Facebook
    • Google Bookmarks

    css.php